From 06f55d0eeac754249f62b9361b9b119138430494 Mon Sep 17 00:00:00 2001 From: Anders Brams Date: Mon, 25 Oct 2021 00:28:59 +0200 Subject: [PATCH] Following new linter --- src/constants.ts | 10 +- src/decorators.ts | 54 ++--- src/interfaces.ts | 23 +-- src/utils.ts | 11 +- test/features/decorator_middleware.test.ts | 220 +++++++++++---------- tslint.json | 60 ------ 6 files changed, 160 insertions(+), 218 deletions(-) delete mode 100644 tslint.json diff --git a/src/constants.ts b/src/constants.ts index 1f98cb7d..46cc46a9 100644 --- a/src/constants.ts +++ b/src/constants.ts @@ -5,11 +5,11 @@ export const TYPE = { }; export const METADATA_KEY = { - controller: "inversify-express-utils:controller", - controllerMethod: "inversify-express-utils:controller-method", - controllerParameter: "inversify-express-utils:controller-parameter", - httpContext: "inversify-express-utils:httpcontext", - middleware: "inversify-express-utils:middleware" + controller: 'inversify-express-utils:controller', + controllerMethod: 'inversify-express-utils:controller-method', + controllerParameter: 'inversify-express-utils:controller-parameter', + httpContext: 'inversify-express-utils:httpcontext', + middleware: 'inversify-express-utils:middleware', }; export enum PARAMETER_TYPE { diff --git a/src/decorators.ts b/src/decorators.ts index acef68b2..47252914 100644 --- a/src/decorators.ts +++ b/src/decorators.ts @@ -1,26 +1,32 @@ -import * as express from "express"; -import { inject, injectable, decorate } from "inversify"; -import { Controller, ControllerMetadata, ControllerParameterMetadata, HandlerDecorator, interfaces, Middleware, ParameterMetadata } from "./index"; -import { TYPE, METADATA_KEY, PARAMETER_TYPE } from "./constants"; -import { getMiddlewareMetadata, getOrCreateMetadata } from "./utils"; - +import {inject, injectable, decorate} from 'inversify'; +import { + Controller, ControllerMetadata, ControllerParameterMetadata, + HandlerDecorator, interfaces, Middleware, MiddlewareMetaData, ParameterMetadata, +} from './index'; +import {TYPE, METADATA_KEY, PARAMETER_TYPE} from './constants'; +import {getMiddlewareMetadata, getOrCreateMetadata} from './utils'; export const injectHttpContext = inject(TYPE.HttpContext); -function defineMiddlewareMetadata(target: any, metaDataKey: string, ...middleware: interfaces.Middleware[]) { - // We register decorated middleware meteadata in a map, e.g. { "TestController": [ your middleware here ] } - const middlewareMap: interfaces.MiddlewareMetaData = getOrCreateMetadata(METADATA_KEY.middleware, target, { }); +function defineMiddlewareMetadata( + target: any, metaDataKey: string, ...middleware: Array +): void { + // We register decorated middleware meteadata in a map, e.g. { "controller": [ middleware ] } + const middlewareMap: MiddlewareMetaData = getOrCreateMetadata( + METADATA_KEY.middleware, target, + { }, + ); if (!(metaDataKey in middlewareMap)) { middlewareMap[metaDataKey] = []; } - middlewareMap[metaDataKey].push(...middleware); + middlewareMap[metaDataKey]?.push(...middleware); Reflect.defineMetadata(METADATA_KEY.middleware, middlewareMap, target); } -export function withMiddleware(...middleware: interfaces.Middleware[]) { - return function(target: any, methodName?: string, descriptor?: PropertyDescriptor) { +export function withMiddleware(...middleware: Array) { + return function (target: any, methodName?: string): void { if (methodName) { defineMiddlewareMetadata(target, methodName, ...middleware); } else { @@ -29,16 +35,15 @@ export function withMiddleware(...middleware: interfaces.Middleware[]) { }; } -export function controller(path: string, ...middleware: interfaces.Middleware[]) { - return function (target: any) { - +export function controller(path: string, ...middleware: Array) { + return function (target: any): void { // Get the list of middleware registered with @middleware() decorators const decoratedMiddleware = getMiddlewareMetadata(target.constructor, target.name); - let currentMetadata: interfaces.ControllerMetadata = { + const currentMetadata: interfaces.ControllerMetadata = { middleware: middleware.concat(decoratedMiddleware), - path: path, - target: target + path, + target, }; decorate(injectable(), target); @@ -93,12 +98,13 @@ export function httpDelete(path: string, ...middleware: Array): Hand return httpMethod('delete', path, ...middleware); } -export function httpMethod(method: string, path: string, ...middleware: interfaces.Middleware[]): interfaces.HandlerDecorator { - return function (target: any, key: string, value: any) { - +export function httpMethod( + method: string, path: string, ...middleware: Array +): interfaces.HandlerDecorator { + return function (target: any, key: string) { const decoratedMiddleware = getMiddlewareMetadata(target, key); - let metadata: interfaces.ControllerMethodMetadata = { + const metadata: interfaces.ControllerMethodMetadata = { key, method, middleware: middleware.concat(decoratedMiddleware), @@ -106,10 +112,10 @@ export function httpMethod(method: string, path: string, ...middleware: interfac target, }; - let metadataList: interfaces.ControllerMethodMetadata[] = getOrCreateMetadata( + const metadataList: Array = getOrCreateMetadata( METADATA_KEY.controllerMethod, target.constructor, - [] + [], ); metadataList.push(metadata); diff --git a/src/interfaces.ts b/src/interfaces.ts index 187c58f1..ea48aa83 100644 --- a/src/interfaces.ts +++ b/src/interfaces.ts @@ -1,18 +1,17 @@ -import * as express from "express"; -import { interfaces as inversifyInterfaces } from "inversify"; -import { PARAMETER_TYPE } from "./constants"; -import { HttpResponseMessage } from "./httpResponseMessage"; - +import * as express from 'express'; +import {interfaces as inversifyInterfaces} from 'inversify'; +import {PARAMETER_TYPE} from './constants'; +import {HttpResponseMessage} from './httpResponseMessage'; export type Middleware = (inversifyInterfaces.ServiceIdentifier | express.RequestHandler); export interface MiddlewareMetaData { - [identifier: string]: Middleware[]; + [identifier: string]: Array; } export interface ControllerMetadata { path: string; - middleware: Middleware[]; + middleware: Array; target: any; } @@ -22,7 +21,7 @@ export interface ControllerMethodMetadata extends ControllerMetadata { } export interface ControllerParameterMetadata { - [methodName: string]: ParameterMetadata[]; + [methodName: string]: Array; } export interface ParameterMetadata { @@ -34,13 +33,9 @@ export interface ParameterMetadata { export interface Controller { } -export interface HandlerDecorator { - (target: any, key: string, value: any): void; -} +export type HandlerDecorator = (target: any, key: string, value: any) => void; -export interface ConfigFunction { - (app: express.Application): void; -} +export type ConfigFunction = (app: express.Application) => void; export interface RoutingConfig { rootPath: string; diff --git a/src/utils.ts b/src/utils.ts index fd911509..8bf6ebbb 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -1,4 +1,4 @@ -import { interfaces } from 'inversify'; +import {interfaces} from 'inversify'; import { Controller, ControllerMetadata, @@ -27,16 +27,16 @@ export function getControllersFromMetadata(): Array Controller> { Reflect, ) || []; - return arrayOfControllerMetadata.map((metadata) => metadata.target); + return arrayOfControllerMetadata.map(metadata => metadata.target); } -export function getMiddlewareMetadata(constructor: any, key: string): interfaces.Middleware[] { +export function getMiddlewareMetadata(constructor: any, key: string): Array { const middlewareMetadata = Reflect.getMetadata(METADATA_KEY.middleware, constructor) || {}; return middlewareMetadata[key] || []; } -export function getControllerMetadata(constructor: any) { - let controllerMetadata: ControllerMetadata = Reflect.getMetadata( +export function getControllerMetadata(constructor: any): ControllerMetadata { + const controllerMetadata: ControllerMetadata = Reflect.getMetadata( METADATA_KEY.controller, constructor, ); @@ -101,4 +101,3 @@ export function getOrCreateMetadata(key: string, target: object, defaultValue return Reflect.getMetadata(key, target); } - diff --git a/test/features/decorator_middleware.test.ts b/test/features/decorator_middleware.test.ts index 63e7b02a..11e5d4c0 100644 --- a/test/features/decorator_middleware.test.ts +++ b/test/features/decorator_middleware.test.ts @@ -1,68 +1,68 @@ -import * as express from "express"; -import { expect } from "chai"; -import { interfaces } from "../../src/interfaces"; -import { METADATA_KEY } from "../../src/constants"; -import * as supertest from "supertest"; +import * as express from 'express'; +import {expect} from 'chai'; +import * as supertest from 'supertest'; +import {Container} from 'inversify'; +import {METADATA_KEY} from '../../src/constants'; import { - controller, httpGet, httpMethod, httpPut, withMiddleware -} from "../../src/decorators"; -import { cleanUpMetadata } from "../../src/utils"; -import { Container } from "inversify"; -import { BaseMiddleware, InversifyExpressServer } from "../../src"; + interfaces, BaseMiddleware, ControllerMethodMetadata, InversifyExpressServer, +} from '../../src/index'; +import { + controller, httpGet, httpMethod, httpPut, withMiddleware, +} from '../../src/decorators'; +import {cleanUpMetadata} from '../../src/utils'; function cleanUpMidDecTestControllerMetadata() { class MidDecTestController { } Reflect.defineMetadata(METADATA_KEY.middleware, {}, MidDecTestController.constructor); } -describe("Unit Test: @middleware decorator", () => { - - beforeEach((done) => { +describe('Unit Test: @middleware decorator', () => { + beforeEach(done => { cleanUpMetadata(); cleanUpMidDecTestControllerMetadata(); done(); }); - it("should add method metadata to a class when a handler is decorated with @withMiddleware", (done) => { - const functionMiddleware = () => { return; }; - const identifierMiddleware = Symbol.for("foo"); - const path = "foo"; - const method = "get"; + it('should add method metadata to a class when a handler is decorated with @withMiddleware', done => { + const functionMiddleware = () => { }; + const identifierMiddleware = Symbol.for('foo'); + const path = 'foo'; + const method = 'get'; class MidDecTestController { @httpMethod(method, path) @withMiddleware(functionMiddleware) - public test() { return; } + public test() { } @httpMethod(method, path) @withMiddleware(functionMiddleware, identifierMiddleware) - public test2() { return; } + public test2() { } } - const methodMetadata: interfaces.ControllerMethodMetadata[] = Reflect.getMetadata( + const methodMetadata: Array = Reflect.getMetadata( METADATA_KEY.controllerMethod, - MidDecTestController + MidDecTestController, ); - const [ testMetaData, test2MetaData ] = methodMetadata; - expect(testMetaData.middleware.length).equal(1); - expect(test2MetaData.middleware.length).equal(2); - expect(testMetaData.middleware).eql([functionMiddleware]); - expect(test2MetaData.middleware).eql([functionMiddleware, identifierMiddleware]); + const [testMetaData, test2MetaData] = methodMetadata; + expect(testMetaData?.middleware.length).equal(1); + expect(test2MetaData?.middleware.length).equal(2); + expect(testMetaData?.middleware).eql([functionMiddleware]); + expect(test2MetaData?.middleware).eql([functionMiddleware, identifierMiddleware]); done(); }); - it("should add class metadata to a controller class when decorated with @withMiddleware", (done) => { - const identifierMiddleware = Symbol.for("foo"); - const functionMiddleware = () => { return; }; + it('should add class metadata to a controller class when decorated with @withMiddleware', done => { + const identifierMiddleware = Symbol.for('foo'); + const functionMiddleware = () => { }; - @controller("/foo") + @controller('/foo') @withMiddleware(identifierMiddleware, functionMiddleware) class MidDecTestController { } const controllerMetaData: interfaces.ControllerMetadata = Reflect.getMetadata( METADATA_KEY.controller, - MidDecTestController + MidDecTestController, ); expect(controllerMetaData.middleware.length).equal(2); @@ -70,21 +70,21 @@ describe("Unit Test: @middleware decorator", () => { done(); }); - it("should be able to add middleware from multiple decorations", (done) => { - const identifierMiddleware = Symbol.for("foo"); - const functionMiddleware = () => { return; }; + it('should be able to add middleware from multiple decorations', done => { + const identifierMiddleware = Symbol.for('foo'); + const functionMiddleware = () => { }; const first = withMiddleware(identifierMiddleware); const second = withMiddleware(functionMiddleware); - @controller("/foo") + @controller('/foo') @first @second class MidDecTestController { } const controllerMetaData: interfaces.ControllerMetadata = Reflect.getMetadata( METADATA_KEY.controller, - MidDecTestController + MidDecTestController, ); expect(controllerMetaData.middleware.length).equal(2); @@ -92,162 +92,164 @@ describe("Unit Test: @middleware decorator", () => { done(); }); - it("should process all requests when decorating a controller", (done) => { + it('should process all requests when decorating a controller', done => { const addTestHeader = withMiddleware( (req: express.Request, res: express.Response, next: express.NextFunction) => { - res.set("test-header", "foo"); + res.set('test-header', 'foo'); next(); - } + }, ); - @controller("/foo") + @controller('/foo') @addTestHeader class MidDecTestController { - @httpGet("/bar") + @httpGet('/bar') public get() { - return { data: "hello" }; + return {data: 'hello'}; } - @httpPut("/baz") + @httpPut('/baz') public put() { - return { data: "there" }; + return {data: 'there'}; } } const container = new Container(); - container.bind("MidDecTestController").to(MidDecTestController); + container.bind('MidDecTestController').to(MidDecTestController); const server = new InversifyExpressServer(container); const app = server.build(); supertest(app) - .get("/foo/bar") - .end((req, res) => { - expect(res.header["test-header"]).equal("foo"); - }); + .get('/foo/bar') + .end((req, res) => { + expect(res.header['test-header']).equal('foo'); + }); supertest(app) - .put("/foo/baz") - .end((req, res) => { - expect(res.header["test-header"]).equal("foo"); - done(); - }); + .put('/foo/baz') + .end((req, res) => { + expect(res.header['test-header']).equal('foo'); + done(); + }); }); - it("should process only specific requests when decorating a handler", (done) => { + it('should process only specific requests when decorating a handler', done => { const addTestHeader = withMiddleware( (req: express.Request, res: express.Response, next: express.NextFunction) => { - res.set("test-header", "foo"); + res.set('test-header', 'foo'); next(); - } + }, ); - @controller("/foo") + @controller('/foo') class MidDecTestController { - @httpGet("/bar") + @httpGet('/bar') public get() { - return { data: "hello" }; + return {data: 'hello'}; } - @httpPut("/baz") + @httpPut('/baz') @addTestHeader public put() { - return { data: "there" }; + return {data: 'there'}; } } const container = new Container(); - container.bind("MidDecTestController").to(MidDecTestController); + container.bind('MidDecTestController').to(MidDecTestController); const server = new InversifyExpressServer(container); const app = server.build(); supertest(app) - .get("/foo/bar") - .end((req, res) => { - expect(res.header["test-header"]).equal(undefined); - }); + .get('/foo/bar') + .end((req, res) => { + expect(res.header['test-header']).equal(undefined); + }); supertest(app) - .put("/foo/baz") - .end((req, res) => { - expect(res.header["test-header"]).equal("foo"); - done(); - }); + .put('/foo/baz') + .end((req, res) => { + expect(res.header['test-header']).equal('foo'); + done(); + }); }); - it("should process requests with both controller- and handler middleware", (done) => { + it('should process requests with both controller- and handler middleware', done => { const addHandlerHeader = withMiddleware( (req: express.Request, res: express.Response, next: express.NextFunction) => { - res.set("test-handler", "hello there!"); + res.set('test-handler', 'hello there!'); next(); - } + }, ); const addControllerHeader = withMiddleware( (req: express.Request, res: express.Response, next: express.NextFunction) => { - res.set("test-controller", "general kenobi"); + res.set('test-controller', 'general kenobi'); next(); - } + }, ); - @controller("/foo") + @controller('/foo') @addControllerHeader class MidDecTestController { - @httpGet("/bar") + @httpGet('/bar') public get() { - return { data: "hello" }; + return {data: 'hello'}; } - @httpPut("/baz") + @httpPut('/baz') @addHandlerHeader public put() { - return { data: "there" }; + return {data: 'there'}; } } const container = new Container(); - container.bind("MidDecTestController").to(MidDecTestController); + container.bind('MidDecTestController').to(MidDecTestController); const server = new InversifyExpressServer(container); const app = server.build(); supertest(app) - .get("/foo/bar") - .end((req, res) => { - expect(res.header["test-controller"]).equal("general kenobi"); - expect(res.header["test-handler"]).equal(undefined); - }); + .get('/foo/bar') + .end((req, res) => { + expect(res.header['test-controller']).equal('general kenobi'); + expect(res.header['test-handler']).equal(undefined); + }); supertest(app) - .put("/foo/baz") - .end((req, res) => { - expect(res.header["test-controller"]).equal("general kenobi"); - expect(res.header["test-handler"]).equal("hello there!"); - done(); - }); + .put('/foo/baz') + .end((req, res) => { + expect(res.header['test-controller']).equal('general kenobi'); + expect(res.header['test-handler']).equal('hello there!'); + done(); + }); }); - it("should be able to inject BaseMiddleware services by identifier", (done) => { + it('should be able to inject BaseMiddleware services by identifier', done => { const container = new Container(); class MidDecTestMiddleware extends BaseMiddleware { - public handler(req: express.Request, res: express.Response, next: express.NextFunction) { - res.set("test-base-middleware", "working"); + public handler( + req: express.Request, res: express.Response, next: express.NextFunction, + ) { + res.set('test-base-middleware', 'working'); next(); } } - container.bind("TestMiddleware").to(MidDecTestMiddleware); + container.bind('TestMiddleware').to(MidDecTestMiddleware); - @controller("/foo") - @withMiddleware("TestMiddleware") + @controller('/foo') + @withMiddleware('TestMiddleware') class MidDecTestController { - @httpGet("/bar") + @httpGet('/bar') public get() { - return { data: "hello" }; + return {data: 'hello'}; } } - container.bind("MidDecTestController").to(MidDecTestController); + container.bind('MidDecTestController').to(MidDecTestController); const server = new InversifyExpressServer(container); const app = server.build(); supertest(app) - .get("/foo/bar") - .end((req, res) => { - expect(res.header["test-base-middleware"]).equal("working"); - done(); - }); + .get('/foo/bar') + .end((req, res) => { + expect(res.header['test-base-middleware']).equal('working'); + done(); + }); }); }); diff --git a/tslint.json b/tslint.json deleted file mode 100644 index 2da77687..00000000 --- a/tslint.json +++ /dev/null @@ -1,60 +0,0 @@ -{ - "rules": { - "class-name": true, - "comment-format": [true, "check-space"], - "curly": true, - "eofline": true, - "forin": true, - "indent": [true, "spaces"], - "label-position": true, - "max-line-length": [true, 140], - "member-access": true, - "member-ordering": false, - "no-arg": true, - "no-bitwise": true, - "no-console": [true, - "debug", - "info", - "time", - "timeEnd", - "trace" - ], - "no-construct": true, - "no-debugger": true, - "no-duplicate-variable": true, - "no-empty": true, - "no-eval": true, - "no-inferrable-types": true, - "no-shadowed-variable": true, - "no-switch-case-fall-through": false, - "no-trailing-whitespace": true, - "no-unused-expression": true, - "no-var-keyword": true, - "one-line": [true, - "check-open-brace", - "check-catch", - "check-else", - "check-whitespace" - ], - "quotemark": [true, "double", "avoid-escape"], - "radix": true, - "semicolon": true, - "trailing-comma": false, - "triple-equals": [true, "allow-null-check"], - "typedef-whitespace": [true, { - "call-signature": "nospace", - "index-signature": "nospace", - "parameter": "nospace", - "property-declaration": "nospace", - "variable-declaration": "nospace" - }], - "variable-name": false, - "whitespace": [true, - "check-branch", - "check-decl", - "check-operator", - "check-separator", - "check-type" - ] - } -}