fix: middlewares can be new instance

OpenZer0 · Nov 28, 2022 · d46e80f · d46e80f
1 parent 03eed87
commit d46e80f
Show file tree

Hide file tree

Showing 8 changed files with 34 additions and 11 deletions.
diff --git a/README.md b/README.md
@@ -240,7 +240,7 @@ export class LogMiddleware2 implements IMiddleware {
 
 // ...
     @BeforeMiddleware(LogMiddleware1)
-    @AfterMiddleware(LogMiddleware2, LogMiddleware2) // use as many you want
+    @AfterMiddleware(LogMiddleware2, LogMiddleware2) // use as many you want, can be new instance
     @Get('/users')
     getTest(){
         return {user: "test"}

diff --git a/example/app.ts b/example/app.ts
@@ -18,7 +18,7 @@ async function main() {
         globalMiddlewares: [LogMiddleware],
         openapi: {
             spec: {info: {title: "test project", version: "3", description: "this is the test project decription"}, openapi: "3.0.0"},
-            swaggerUi: "/",
+            swaggerUi: "/docs2",
             apiDocs: "docs"
         },
         assetFolders: [{root: "/assets", path: path.join(__dirname, "static")}]

diff --git a/example/controllers/user.controller.ts b/example/controllers/user.controller.ts
@@ -13,7 +13,7 @@ import { Controller, HttpError, Post } from "../../lib";
 import { OtherValidator, UserValidator } from "../user.validator";
 import { ApiDocs } from "../../lib/decorators/openapi/result.decorator";
 import { NotImplementedError } from "../../lib/error/http/bad-request.error";
-import { LogMiddleware2, LogMiddleware3 } from "../middlewares/log.middleware";
+import { LogMe, LogMiddleware2, LogMiddleware3 } from "../middlewares/log.middleware";
 import { BeforeMiddleware } from "../../lib/decorators/middleware/before-middleware.decorator";
 import { AfterMiddleware } from "../../lib/decorators/middleware/after-middleware.decorator";
 
@@ -23,6 +23,7 @@ export class UserController {
 
     // @Middleware({beforeMiddlewares: [LogMiddleware2], afterMiddlewares: []})
     @BeforeMiddleware(LogMiddleware2)
+    @BeforeMiddleware(new LogMe("this is an instance message"))
     @BeforeMiddleware(LogMiddleware2)
     @AfterMiddleware(LogMiddleware3)
     @Get('/users')

diff --git a/example/middlewares/log.middleware.ts b/example/middlewares/log.middleware.ts
@@ -9,6 +9,16 @@ export class StringFactory {
   }
 }
 
+@Injectable()
+export class LogMe implements IMiddleware {
+  constructor(private readonly message: string) {
+  }
+  handle(req: express.Request, res: express.Response, next: Function) {
+    console.log(this.message)
+    next()
+  }
+}
+
 @Injectable()
 export class LogMiddleware implements IMiddleware {
   constructor(private readonly stringFactory: StringFactory) {

diff --git a/lib/bonfire-server.ts b/lib/bonfire-server.ts
@@ -49,7 +49,11 @@ export class BonfireServer {
                 globalPipes: [],
                 globalPrefix: '/',
                 globalMiddlewares: [],
-                openapi: { swaggerUi: 'swagger-ui', apiDocs: 'api-docs', spec: {info: {title: "bonfire-app", version: "3"}, openapi: "3.0.0"} },
+                openapi: {
+                    swaggerUi: 'swagger-ui',
+                    apiDocs: 'api-docs',
+                    spec: { info: { title: 'bonfire-app', version: '3' }, openapi: '3.0.0' },
+                },
                 assetFolders: [],
             },
             ...this.ctx,
@@ -115,7 +119,11 @@ export class BonfireServer {
         const getBeforeMiddlewares = () => {
             return Promise.all(
                 (middlewareMeta?.beforeMiddlewares || []).map(async (middleware) => {
-                    const resolvedMiddleware = await BonfireServer.container.resolveByType(middleware);
+                    console.log(middleware, typeof middleware == 'function')
+                    let resolvedMiddleware: IMiddleware = middleware;
+                    if (typeof middleware == 'function') {
+                        resolvedMiddleware = await BonfireServer.container.resolveByType(middleware);
+                    }
                     return async (req, res, next) => {
                         await resolvedMiddleware.handle(req, res, next);
                     };
@@ -126,7 +134,11 @@ export class BonfireServer {
         const getAfterMiddlewares = () => {
             return Promise.all(
                 (middlewareMeta?.afterMiddlewares || []).map(async (middleware) => {
-                    const resolvedMiddleware = await BonfireServer.container.resolveByType(middleware);
+                    console.log(middleware, typeof middleware == 'function')
+                    let resolvedMiddleware: IMiddleware = middleware;
+                    if (typeof middleware == 'function') {
+                        resolvedMiddleware = await BonfireServer.container.resolveByType(middleware);
+                    }
                     return async (req, res, next) => {
                         await resolvedMiddleware.handle(req, res, next);
                     };
@@ -143,7 +155,7 @@ export class BonfireServer {
                 } catch (e) {
                     this.errorHandler.handle(e, req, res);
                 }
-                next()
+                next();
             },
             ...(await getAfterMiddlewares()),
         );

diff --git a/lib/decorators/middleware/after-middleware.decorator.ts b/lib/decorators/middleware/after-middleware.decorator.ts
@@ -2,7 +2,7 @@ import { Type } from 'type-chef-di';
 import { IMiddleware } from '../../middleware/middleware.interface';
 import { addMiddlewareMeta } from './middleware.decorator';
 
-export function AfterMiddleware(...middlewares: Type<IMiddleware>[]) {
+export function AfterMiddleware(...middlewares: Type<IMiddleware>[] | IMiddleware[]) {
     return (target: object, propertyKey: string, descriptor: PropertyDescriptor) => {
         addMiddlewareMeta(target, propertyKey, { beforeMiddlewares: [], afterMiddlewares: middlewares });
     };

diff --git a/lib/decorators/middleware/before-middleware.decorator.ts b/lib/decorators/middleware/before-middleware.decorator.ts
@@ -2,7 +2,7 @@ import { Type } from 'type-chef-di';
 import { IMiddleware } from '../../middleware/middleware.interface';
 import { addMiddlewareMeta } from './middleware.decorator';
 
-export function BeforeMiddleware(...middlewares: Type<IMiddleware>[]) {
+export function BeforeMiddleware(...middlewares: Type<IMiddleware>[] | IMiddleware[]) {
     return (target: object, propertyKey: string, descriptor: PropertyDescriptor) => {
         addMiddlewareMeta(target, propertyKey, { beforeMiddlewares: middlewares, afterMiddlewares: [] });
     };

diff --git a/lib/decorators/middleware/middleware.decorator.ts b/lib/decorators/middleware/middleware.decorator.ts
@@ -3,8 +3,8 @@ import { IMiddleware } from '../../middleware/middleware.interface';
 import { Constants } from '../../Constants';
 
 export interface IMiddlewareMeta {
-    beforeMiddlewares: Type<IMiddleware>[];
-    afterMiddlewares: Type<IMiddleware>[];
+    beforeMiddlewares: Type<IMiddleware>[] | IMiddleware[];
+    afterMiddlewares: Type<IMiddleware>[] | IMiddleware[];
 }
 
 export function Middleware(options: IMiddlewareMeta) {