@tsed/common 6.85.0 → 6.87.0

package/lib/builder/PlatformControllerBuilder.d.ts

@@ -1,19 +1,17 @@
 import { InjectorService } from "@tsed/di";
 import { ControllerProvider } from "../domain/ControllerProvider";
-import { PlatformRouterMethods } from "../interfaces/PlatformRouterMethods";
+import { PlatformRouter } from "../services/PlatformRouter";
 /**
  * @ignore
  */
-export declare class PlatformControllerBuilder {
-    private provider;
-    constructor(provider: ControllerProvider);
-    /**
-     * @returns {any}
-     */
-    build(injector: InjectorService): PlatformRouterMethods;
-    private buildEndpoints;
-    private buildEndpoint;
-    private getMiddlewares;
-    private buildChildrenCtrls;
-    private buildMiddlewares;
-}
+export declare function getRouter(injector: InjectorService, provider: ControllerProvider): any;
+/**
+ * @ignore
+ */
+export declare function createRouter(injector: InjectorService, provider: ControllerProvider): PlatformRouter;
+/**
+ * @ignore
+ * @param injector
+ * @param provider
+ */
+export declare function buildRouter(injector: InjectorService, provider: ControllerProvider): PlatformRouter<TsED.Router>;

package/lib/domain/ControllerProvider.d.ts

@@ -1,7 +1,6 @@
 import { ControllerMiddlewares, Provider, TokenProvider } from "@tsed/di";
-import { PlatformRouterMethods } from "../interfaces/PlatformRouterMethods";
 export declare class ControllerProvider<T = any> extends Provider<T> {
-    private router;
+    readonly tokenRouter: string;
     constructor(provide: TokenProvider, options?: Partial<Provider>);
     /**
      *
@@ -22,6 +21,4 @@ export declare class ControllerProvider<T = any> extends Provider<T> {
      * @param middlewares
      */
     set middlewares(middlewares: ControllerMiddlewares);
-    getRouter<T extends PlatformRouterMethods = any>(): T;
-    setRouter(router: PlatformRouterMethods): this;
 }

package/lib/index.d.ts

@@ -19,6 +19,5 @@ export * from "./interfaces";
 export * from "./middlewares";
 export * from "./domain";
 export * from "./services";
-export * from "./registries/ControllerRegistry";
 export * from "./utils";
 export * from "./PlatformModule";

package/lib/index.js

@@ -986,6 +986,7 @@ const PLATFORM_ROUTER_OPTIONS = Symbol.for("PlatformRouterOptions");
 exports.PlatformRouter = PlatformRouter_1 = class PlatformRouter {
   constructor(platformHandler) {
     this.platformHandler = platformHandler;
+    this.isBuilt = false;
     this.rawRouter = this.raw = PlatformRouter_1.createRawRouter();
   }
   /**
@@ -1292,72 +1293,77 @@ tslib.__decorate([tslib.__param(0, platformParams.Context()), tslib.__metadata("
 
 exports.AcceptMimesMiddleware = tslib.__decorate([platformMiddlewares.Middleware()], exports.AcceptMimesMiddleware);
 
-/**
- * Create Ts.ED context handler
- * @param fn
- * @ignore
- */
+const ROUTER_OPTIONS = Symbol.for("ROUTER_OPTIONS");
 
-function useCtxHandler(fn) {
-  fn.type = exports.HandlerType.CTX_FN;
-  return fn;
-}
+let AUTO_INC = 0;
+class ControllerProvider extends di.Provider {
+  constructor(provide, options = {}) {
+    super(provide, options);
+    this.type = di.ProviderType.CONTROLLER;
+    this.tokenRouter = `${this.name}_ROUTER_${AUTO_INC++}`;
+  }
+  /**
+   *
+   */
 
-/**
- * @ignore
- */
 
-function formatMethod(method) {
-  return (method === schema.OperationMethods.CUSTOM ? "use" : method || "use").toLowerCase();
-}
-/**
- * @ignore
- */
+  get routerOptions() {
+    return this.store.get(ROUTER_OPTIONS) || {};
+  }
+  /**
+   *
+   * @param value
+   */
 
 
-class PlatformControllerBuilder {
-  constructor(provider) {
-    this.provider = provider;
+  set routerOptions(value) {
+    this.store.set(ROUTER_OPTIONS, value);
   }
   /**
-   * @returns {any}
+   *
+   * @returns {any[]}
    */
 
 
-  build(injector) {
-    const {
-      middlewares: {
-        useBefore
-      }
-    } = this.provider; // Controller lifecycle
+  get middlewares() {
+    return Object.assign({
+      use: [],
+      useAfter: [],
+      useBefore: []
+    }, this.store.get("middlewares", {}));
+  }
+  /**
+   *
+   * @param middlewares
+   */
 
-    this.buildMiddlewares(useBefore) // Controller before-middleware
-    .buildEndpoints() // All endpoints and his middlewares
-    .buildChildrenCtrls(injector); // Children controllers
 
-    return this.provider.getRouter();
-  }
+  set middlewares(middlewares) {
+    const mdlwrs = this.middlewares;
 
-  buildEndpoints() {
-    schema.getOperationsRoutes(this.provider.token).forEach(operationRoute => {
-      this.buildEndpoint(operationRoute);
-    });
-    return this;
-  }
+    const concat = (key, a, b) => a[key] = a[key].concat(b[key]);
 
-  buildEndpoint(operationRoute) {
-    let handlers = this.getMiddlewares(operationRoute);
-    const router = this.provider.getRouter();
-    router.addRoute({
-      handlers,
-      token: operationRoute.token,
-      method: formatMethod(operationRoute.method),
-      path: operationRoute.path,
-      isFinal: operationRoute.isFinal
+    Object.keys(middlewares).forEach(key => {
+      concat(key, mdlwrs, middlewares);
     });
+    this.store.set("middlewares", mdlwrs);
   }
 
-  getMiddlewares(operationRoute) {
+}
+
+/**
+ * Create Ts.ED context handler
+ * @param fn
+ * @ignore
+ */
+
+function useCtxHandler(fn) {
+  fn.type = exports.HandlerType.CTX_FN;
+  return fn;
+}
+
+exports.PlatformMiddlewaresChain = class PlatformMiddlewaresChain {
+  get(provider, operationRoute) {
     const {
       endpoint
     } = operationRoute;
@@ -1371,11 +1377,10 @@ class PlatformControllerBuilder {
         use,
         useAfter
       }
-    } = this.provider;
+    } = provider;
     const hasFiles = [...operationRoute.endpoint.children.values()].find(item => item.paramType === platformParams.ParamTypes.FILES);
     return [].concat(useCtxHandler(bindEndpointMiddleware(endpoint))).concat(exports.PlatformAcceptMimesMiddleware).concat(hasFiles && exports.PlatformMulterMiddleware).concat(beforeMiddlewares) // Endpoint before-middlewares
     .concat(use) // Controller use-middlewares
-    // .concat(endpoint.cache && PlatformCacheMiddleware)
     .concat(mldwrs) // Endpoint middlewares
     .concat(endpoint) // Endpoint metadata
     .concat(afterMiddlewares) // Endpoint after-middlewares
@@ -1383,32 +1388,97 @@ class PlatformControllerBuilder {
     .filter(item => !!item);
   }
 
-  buildChildrenCtrls(injector) {
-    const {
-      children
-    } = this.provider;
-    const router = this.provider.getRouter();
+};
+exports.PlatformMiddlewaresChain = tslib.__decorate([di.Injectable()], exports.PlatformMiddlewaresChain);
+
+di.GlobalProviders.createRegistry(di.ProviderType.CONTROLLER, ControllerProvider, {
+  onInvoke(provider, locals, {
+    injector
+  }) {
+    const router = createRouter(injector, provider);
+    locals.set(exports.PlatformRouter, router);
+  }
+
+});
+/**
+ * @ignore
+ */
+
+function formatMethod(method) {
+  return (method === schema.OperationMethods.CUSTOM ? "use" : method || "use").toLowerCase();
+}
+/**
+ * @ignore
+ */
+
+
+function getRouter(injector, provider) {
+  return injector.get(provider.tokenRouter);
+}
+/**
+ * @ignore
+ */
+
+function createRouter(injector, provider) {
+  const token = provider.tokenRouter;
+
+  if (injector.has(token)) {
+    return getRouter(injector, provider);
+  }
+
+  const router = exports.PlatformRouter.create(injector, provider.routerOptions);
+  return injector.add(token, {
+    useValue: router
+  }).invoke(token);
+}
+/**
+ * @ignore
+ * @param injector
+ * @param provider
+ */
+
+function buildRouter(injector, provider) {
+  const {
+    middlewares: {
+      useBefore
+    },
+    children
+  } = provider; // Controller lifecycle
+
+  const router = createRouter(injector, provider);
+
+  if (!router.isBuilt) {
+    router.isBuilt = true;
+    const platformMiddlewaresChain = injector.get(exports.PlatformMiddlewaresChain);
+    useBefore // Controller before-middleware
+    .filter(o => typeof o === "function").forEach(middleware => {
+      router.use(middleware);
+    }); // build all endpoints and his middlewares
+
+    schema.getOperationsRoutes(provider.token).forEach(operationRoute => {
+      const handlers = platformMiddlewaresChain == null ? void 0 : platformMiddlewaresChain.get(provider, operationRoute);
+      router.addRoute({
+        handlers,
+        token: operationRoute.token,
+        method: formatMethod(operationRoute.method),
+        path: operationRoute.path,
+        isFinal: operationRoute.isFinal
+      });
+    }); // build children controllers
+
     children.forEach(child => {
-      const provider = injector.getProvider(child);
+      const childProvider = injector.getProvider(child);
       /* istanbul ignore next */
 
-      if (!provider) {
+      if (!childProvider) {
         throw new Error("Controller component not found in the ControllerRegistry");
       }
 
-      new PlatformControllerBuilder(provider).build(injector);
-      router.use(provider.path, provider.getRouter());
-    });
-  }
-
-  buildMiddlewares(middlewares) {
-    const router = this.provider.getRouter();
-    middlewares.filter(o => typeof o === "function").forEach(middleware => {
-      router.use(middleware);
+      router.use(childProvider.path, buildRouter(injector, childProvider));
     });
-    return this;
   }
 
+  return router;
 }
 
 /**
@@ -2005,71 +2075,6 @@ class PlatformRouteDetails extends schema.JsonOperationRoute {
 
 }
 
-const ROUTER_OPTIONS = Symbol.for("ROUTER_OPTIONS");
-
-class ControllerProvider extends di.Provider {
-  constructor(provide, options = {}) {
-    super(provide, options);
-    this.type = di.ProviderType.CONTROLLER;
-  }
-  /**
-   *
-   */
-
-
-  get routerOptions() {
-    return this.store.get(ROUTER_OPTIONS) || {};
-  }
-  /**
-   *
-   * @param value
-   */
-
-
-  set routerOptions(value) {
-    this.store.set(ROUTER_OPTIONS, value);
-  }
-  /**
-   *
-   * @returns {any[]}
-   */
-
-
-  get middlewares() {
-    return Object.assign({
-      use: [],
-      useAfter: [],
-      useBefore: []
-    }, this.store.get("middlewares", {}));
-  }
-  /**
-   *
-   * @param middlewares
-   */
-
-
-  set middlewares(middlewares) {
-    const mdlwrs = this.middlewares;
-
-    const concat = (key, a, b) => a[key] = a[key].concat(b[key]);
-
-    Object.keys(middlewares).forEach(key => {
-      concat(key, mdlwrs, middlewares);
-    });
-    this.store.set("middlewares", mdlwrs);
-  }
-
-  getRouter() {
-    return this.router;
-  }
-
-  setRouter(router) {
-    this.router = router;
-    return this;
-  }
-
-}
-
 /**
  * @deprecated Since 2020-11-11. Use getProperties from @tsed/schema
  */
@@ -2093,13 +2098,6 @@ exports.PropertyMetadata = class PropertyMetadata extends schema.JsonPropertySto
 };
 exports.PropertyMetadata = tslib.__decorate([schema.JsonEntityComponent(core.DecoratorTypes.PROP)], exports.PropertyMetadata);
 
-di.GlobalProviders.createRegistry(di.ProviderType.CONTROLLER, ControllerProvider, {
-  onInvoke(provider, locals) {
-    locals.set(exports.PlatformRouter, provider.getRouter());
-  }
-
-});
-
 /**
  * `Platform` is used to provide all routes collected by annotation `@Controller`.
  *
@@ -2146,7 +2144,7 @@ exports.Platform = class Platform {
       provider
     });
 
-    this.app.use(ctrlPath, ...[].concat(provider.getRouter().callback()));
+    this.app.use(ctrlPath, ...[].concat(getRouter(injector, provider).callback()));
     this._routes = schema.getOperationsRoutes(provider.token, {
       withChildren: true,
       basePath
@@ -2191,7 +2189,7 @@ exports.Platform = class Platform {
       injector
     } = this;
     injector.getProviders(di.ProviderType.CONTROLLER).map(provider => {
-      provider.setRouter(exports.PlatformRouter.create(injector, provider.routerOptions));
+      createRouter(injector, provider);
     });
   }
   /**
@@ -2206,14 +2204,15 @@ exports.Platform = class Platform {
     } = this;
     injector.getProviders(di.ProviderType.CONTROLLER).map(provider => {
       if (!provider.hasParent()) {
-        return new PlatformControllerBuilder(provider).build(injector);
+        return buildRouter(injector, provider);
       }
     });
   }
 
 };
 exports.Platform = tslib.__decorate([di.Injectable({
-  scope: di.ProviderScope.SINGLETON
+  scope: di.ProviderScope.SINGLETON,
+  imports: [exports.PlatformMiddlewaresChain]
 }), tslib.__metadata("design:paramtypes", [di.InjectorService, exports.PlatformApplication])], exports.Platform);
 
 logger.$log.name = "TSED";
@@ -3510,7 +3509,6 @@ exports.Next = Next;
 exports.PLATFORM_ROUTER_OPTIONS = PLATFORM_ROUTER_OPTIONS;
 exports.PlatformBuilder = PlatformBuilder;
 exports.PlatformContext = PlatformContext;
-exports.PlatformControllerBuilder = PlatformControllerBuilder;
 exports.PlatformModule = PlatformModule;
 exports.PlatformRouteDetails = PlatformRouteDetails;
 exports.PlatformTest = PlatformTest;
@@ -3521,11 +3519,14 @@ exports.Res = Res;
 exports.Response = Response;
 exports.ResponseData = ResponseData;
 exports.bindEndpointMiddleware = bindEndpointMiddleware;
+exports.buildRouter = buildRouter;
 exports.createContext = createContext;
 exports.createHttpServer = createHttpServer;
 exports.createHttpsServer = createHttpsServer;
 exports.createInjector = createInjector;
 exports.createPlatformApplication = createPlatformApplication;
+exports.createRouter = createRouter;
+exports.getRouter = getRouter;
 exports.listenHttpServer = listenHttpServer;
 exports.listenHttpsServer = listenHttpsServer;
 exports.listenServer = listenServer;