@tsed/common 6.75.12 → 6.76.0

package/lib/builder/PlatformControllerBuilder.d.ts

@@ -8,12 +8,12 @@ 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;
 }

package/lib/decorators/method/endpointFn.d.ts

@@ -4,5 +4,6 @@ import { EndpointMetadata } from "../../domain";
  *
  * @param fn
  * @decorator
+ * @deprecated Deprecated since 2021-10-05. Use JsonEntityFn instead.
  */
 export declare function EndpointFn(fn: (endpoint: EndpointMetadata, parameters: DecoratorParameters) => void): MethodDecorator;

package/lib/domain/ControllerProvider.d.ts

@@ -1,24 +1,8 @@
 import { ControllerMiddlewares, Provider, TokenProvider } from "@tsed/di";
-import { JsonEntityStore } from "@tsed/schema";
 import { PlatformRouterMethods } from "../interfaces/PlatformRouterMethods";
-import { EndpointMetadata } from "./EndpointMetadata";
 export declare class ControllerProvider<T = any> extends Provider<T> {
-    readonly entity: JsonEntityStore;
     private router;
     constructor(provide: TokenProvider, options?: Partial<Provider>);
-    get path(): string;
-    set path(path: string);
-    /**
-     *
-     * @returns {EndpointMetadata[]}
-     */
-    get endpoints(): EndpointMetadata[];
-    get children(): TokenProvider[];
-    /**
-     *
-     * @returns {ControllerProvider}
-     */
-    get parent(): TokenProvider | undefined;
     /**
      *
      */
@@ -38,16 +22,6 @@ export declare class ControllerProvider<T = any> extends Provider<T> {
      * @param middlewares
      */
     set middlewares(middlewares: ControllerMiddlewares);
-    /**
-     *
-     * @returns {boolean}
-     */
-    hasChildren(): boolean;
-    /**
-     *
-     * @returns {boolean}
-     */
-    hasParent(): boolean;
     getRouter<T extends PlatformRouterMethods = any>(): T;
     setRouter(router: PlatformRouterMethods): this;
 }

package/lib/domain/EndpointMetadata.d.ts

@@ -46,12 +46,6 @@ export declare class EndpointMetadata extends JsonEntityStore implements Endpoin
     set view(view: EndpointViewOptions);
     get acceptMimes(): string[];
     set acceptMimes(mimes: string[]);
-    /**
-     * Get all endpoints from a given class and his parents.
-     * @param {Type<any>} target
-     * @returns {EndpointMetadata[]}
-     */
-    static getEndpoints(target: Type<any>): EndpointMetadata[];
     /**
      * Get an endpoint.
      * @param target
@@ -84,5 +78,4 @@ export declare class EndpointMetadata extends JsonEntityStore implements Endpoin
      * @param args
      */
     use(args: Function[]): this;
-    clone(): EndpointMetadata;
 }

package/lib/domain/PlatformRouteDetails.d.ts

@@ -1,18 +1,17 @@
 import { EndpointMetadata } from "./EndpointMetadata";
 import { ControllerProvider } from "./ControllerProvider";
+import { JsonOperationRoute } from "@tsed/schema";
 export interface PlatformRouterDetailsOptions {
     provider: ControllerProvider;
     endpoint: EndpointMetadata;
     method: string;
     url: string;
 }
-export declare class PlatformRouteDetails {
-    readonly method: string;
-    readonly url: string;
+export declare class PlatformRouteDetails extends JsonOperationRoute<EndpointMetadata> {
     readonly rawBody: boolean;
-    readonly endpoint: EndpointMetadata;
     readonly provider: ControllerProvider;
-    constructor({ provider, endpoint, method, url }: PlatformRouterDetailsOptions);
+    constructor(options?: Partial<PlatformRouteDetails>);
+    get url(): string;
     get name(): string;
     get className(): string;
     get methodClassName(): string;

package/lib/index.js

@@ -509,7 +509,6 @@ class HandlerMetadata {
 
 }
 
-var EndpointMetadata_1;
 /**
  * EndpointMetadata contains metadata about a controller and his method.
  * Each annotation (@Get, @Body...) attached to a method are stored in a endpoint.
@@ -527,7 +526,7 @@ var EndpointMetadata_1;
  *
  */
 
-exports.EndpointMetadata = EndpointMetadata_1 = class EndpointMetadata extends schema.JsonEntityStore {
+exports.EndpointMetadata = class EndpointMetadata extends schema.JsonEntityStore {
   constructor(options) {
     super(_extends({
       store: core.Store.fromMethod(options.target, options.propertyKey),
@@ -581,21 +580,6 @@ exports.EndpointMetadata = EndpointMetadata_1 = class EndpointMetadata extends s
   set acceptMimes(mimes) {
     this.store.set("acceptMimes", mimes);
   }
-  /**
-   * Get all endpoints from a given class and his parents.
-   * @param {Type<any>} target
-   * @returns {EndpointMetadata[]}
-   */
-
-
-  static getEndpoints(target) {
-    const operations = schema.getOperationsStores(target);
-    return Array.from(operations.values()).map(endpoint => {
-      endpoint = endpoint.clone();
-      endpoint.token = core.classOf(target);
-      return endpoint;
-    });
-  }
   /**
    * Get an endpoint.
    * @param target
@@ -657,26 +641,8 @@ exports.EndpointMetadata = EndpointMetadata_1 = class EndpointMetadata extends s
     return this;
   }
 
-  clone() {
-    const endpoint = new EndpointMetadata_1(_extends({}, this, {
-      target: this.target,
-      propertyKey: this.propertyKey,
-      descriptor: this.descriptor,
-      store: this.store,
-      children: this.children
-    }));
-    endpoint.collectionType = this.collectionType;
-    endpoint._type = this._type;
-    endpoint._operation = this.operation;
-    endpoint._schema = this._schema;
-    endpoint.middlewares = [...this.middlewares];
-    endpoint.afterMiddlewares = [...this.afterMiddlewares];
-    endpoint.beforeMiddlewares = [...this.beforeMiddlewares];
-    return endpoint;
-  }
-
 };
-exports.EndpointMetadata = EndpointMetadata_1 = tslib.__decorate([schema.JsonEntityComponent(core.DecoratorTypes.METHOD), tslib.__metadata("design:paramtypes", [Object])], exports.EndpointMetadata);
+exports.EndpointMetadata = tslib.__decorate([schema.JsonEntityComponent(core.DecoratorTypes.METHOD), tslib.__metadata("design:paramtypes", [Object])], exports.EndpointMetadata);
 
 function isMetadata(input) {
   return input instanceof HandlerMetadata;
@@ -694,7 +660,7 @@ function createHandlerMetadata(injector, obj, routeOptions = {}) {
   let options;
 
   if (obj instanceof exports.EndpointMetadata) {
-    const provider = injector.getProvider(obj.token);
+    const provider = injector.getProvider(routeOptions.token);
     options = {
       token: provider.token,
       target: provider.useClass,
@@ -1038,6 +1004,7 @@ exports.PlatformHandler = tslib.__decorate([di.Injectable({
   scope: di.ProviderScope.SINGLETON
 }), tslib.__metadata("design:paramtypes", [di.InjectorService, platformParams.PlatformParams])], exports.PlatformHandler);
 
+const _excluded$3 = ["method", "path", "handlers"];
 var PlatformRouter_1;
 /**
  * @ignore
@@ -1089,15 +1056,15 @@ exports.PlatformRouter = PlatformRouter_1 = class PlatformRouter {
     const {
       method,
       path,
-      handlers,
-      isFinal
-    } = options; // @ts-ignore
+      handlers
+    } = options,
+          opts = _objectWithoutPropertiesLoose(options, _excluded$3); // @ts-ignore
+
 
-    this.getRouter()[method](path, ...this.mapHandlers(handlers, {
+    this.getRouter()[method](path, ...this.mapHandlers(handlers, _extends({
       method,
-      path,
-      isFinal
-    }));
+      path
+    }, opts)));
     return this;
   }
 
@@ -1386,7 +1353,6 @@ class PlatformControllerBuilder {
     this.provider = provider;
   }
   /**
-   *
    * @returns {any}
    */
 
@@ -1406,48 +1372,32 @@ class PlatformControllerBuilder {
   }
 
   buildEndpoints() {
-    const {
-      endpoints
-    } = this.provider;
-    const operationPaths = new Map();
-
-    const getKey = (method, path) => `${method}-${path}`;
-
-    const updateFinalRouteState = key => {
-      if (operationPaths.has(key)) {
-        operationPaths.get(key).isFinal = false;
-      }
-    };
-
-    const setFinalRoute = (key, operationPath) => {
-      operationPaths.set(key, operationPath);
-      operationPath.isFinal = true;
-    };
-
-    endpoints.forEach(({
-      operation
-    }) => {
-      operation == null ? void 0 : operation.operationPaths.forEach(operationPath => {
-        if (operationPath.method !== schema.OperationMethods.CUSTOM) {
-          const key = getKey(operationPath.method, operationPath.path);
-          updateFinalRouteState(key);
-          updateFinalRouteState(getKey(schema.OperationMethods.ALL, operationPath.path));
-          setFinalRoute(key, operationPath);
-        }
-      });
-    });
-    endpoints.forEach(endpoint => {
-      this.buildEndpoint(endpoint);
+    schema.getOperationsRoutes(this.provider.token).forEach(operationRoute => {
+      this.buildEndpoint(operationRoute);
     });
     return this;
   }
 
-  buildEndpoint(endpoint) {
+  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
+    });
+  }
+
+  getMiddlewares(operationRoute) {
+    const {
+      endpoint
+    } = operationRoute;
     const {
       beforeMiddlewares,
       middlewares: mldwrs,
-      afterMiddlewares,
-      operation
+      afterMiddlewares
     } = endpoint;
     const {
       middlewares: {
@@ -1455,35 +1405,15 @@ class PlatformControllerBuilder {
         useAfter
       }
     } = this.provider;
-    const router = this.provider.getRouter(); // Endpoint lifecycle
-
-    let handlers = [];
-    const hasFiles = [...endpoint.children.values()].find(item => item.paramType === platformParams.ParamTypes.FILES);
-    handlers = handlers.concat(useCtxHandler(bindEndpointMiddleware(endpoint))).concat(exports.PlatformAcceptMimesMiddleware).concat(hasFiles && exports.PlatformMulterMiddleware).concat(beforeMiddlewares) // Endpoint before-middlewares
+    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
     .concat(useAfter) // Controller after middlewares (equivalent to afterEach)
-    .filter(item => !!item); // Add handlers to the router
-
-    operation == null ? void 0 : operation.operationPaths.forEach(({
-      path,
-      method,
-      isFinal
-    }) => {
-      router.addRoute({
-        method: formatMethod(method),
-        path,
-        handlers,
-        isFinal
-      });
-    });
-
-    if (!(operation != null && operation.operationPaths.size)) {
-      router.use(...handlers);
-    }
+    .filter(item => !!item);
   }
 
   buildChildrenCtrls(injector) {
@@ -2088,18 +2018,14 @@ class PlatformContext extends di.DIContext {
 
 }
 
-class PlatformRouteDetails {
-  constructor({
-    provider,
-    endpoint,
-    method,
-    url
-  }) {
-    this.provider = provider;
-    this.endpoint = endpoint;
-    this.method = method;
-    this.url = url;
-    this.rawBody = !!endpoint.params.find(param => param.paramType === platformParams.ParamTypes.RAW_BODY);
+class PlatformRouteDetails extends schema.JsonOperationRoute {
+  constructor(options = {}) {
+    super(options);
+    this.rawBody = !!this.endpoint.params.find(param => param.paramType === platformParams.ParamTypes.RAW_BODY);
+  }
+
+  get url() {
+    return this.fullPath;
   }
 
   get name() {
@@ -2138,37 +2064,6 @@ class ControllerProvider extends di.Provider {
   constructor(provide, options = {}) {
     super(provide, options);
     this.type = di.ProviderType.CONTROLLER;
-    this.entity = schema.JsonEntityStore.from(provide);
-  }
-
-  get path() {
-    return this.entity.path;
-  }
-
-  set path(path) {
-    this.entity.path = path;
-  }
-  /**
-   *
-   * @returns {EndpointMetadata[]}
-   */
-
-
-  get endpoints() {
-    return exports.EndpointMetadata.getEndpoints(this.provide);
-  }
-
-  get children() {
-    return this.store.get("childrenControllers", []);
-  }
-  /**
-   *
-   * @returns {ControllerProvider}
-   */
-
-
-  get parent() {
-    return this.store.get("parentController");
   }
   /**
    *
@@ -2216,24 +2111,6 @@ class ControllerProvider extends di.Provider {
     });
     this.store.set("middlewares", mdlwrs);
   }
-  /**
-   *
-   * @returns {boolean}
-   */
-
-
-  hasChildren() {
-    return !!this.children.length;
-  }
-  /**
-   *
-   * @returns {boolean}
-   */
-
-
-  hasParent() {
-    return !!this.store.get("parentController");
-  }
 
   getRouter() {
     return this.router;
@@ -2262,9 +2139,12 @@ exports.PropertyMetadata = class PropertyMetadata extends schema.JsonEntityStore
 };
 exports.PropertyMetadata = tslib.__decorate([schema.JsonEntityComponent(core.DecoratorTypes.PROP)], exports.PropertyMetadata);
 
-function getControllerPath(basePath, provider) {
-  return (basePath === provider.path ? provider.path : (basePath || "") + provider.path).replace(/\/\//gi, "/");
-}
+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`.
@@ -2289,42 +2169,44 @@ exports.Platform = class Platform {
     return this._routes;
   }
 
-  $onInit() {
-    this.buildControllers();
-  }
-
   addRoutes(routes) {
     routes.forEach(routeSettings => {
       this.addRoute(routeSettings.route, routeSettings.token);
     });
   }
 
-  addRoute(endpoint, token) {
+  addRoute(basePath, token) {
     const {
       injector
     } = this;
+    const provider = injector.getProvider(token);
 
-    if (injector.hasProvider(token)) {
-      const provider = injector.getProvider(token);
-
-      if (provider.type === di.ProviderType.CONTROLLER) {
-        const route = getControllerPath(endpoint, provider);
-
-        if (!provider.hasParent()) {
-          const routes = this.buildRoutes(route, provider);
+    if (!provider || provider.hasParent()) {
+      return;
+    }
 
-          this._routes.push(...routes);
+    const ctrlPath = schema.concatPath(basePath, schema.JsonEntityStore.from(provider.token).path);
 
-          this._controllers.push({
-            route,
-            provider
-          });
+    this._controllers.push({
+      route: ctrlPath,
+      provider
+    });
 
-          this.app.use(route, ...[].concat(provider.getRouter().callback()));
-        }
+    this.app.use(ctrlPath, ...[].concat(provider.getRouter().callback()));
+    this._routes = schema.getOperationsRoutes(provider.token, {
+      withChildren: true,
+      basePath
+    }).reduce((routes, operationRoute) => {
+      if (injector.hasProvider(token)) {
+        const provider = injector.getProvider(operationRoute.token);
+        const route = new PlatformRouteDetails(_extends({}, operationRoute, {
+          provider
+        }));
+        return routes.concat(route);
       }
-    }
 
+      return routes;
+    }, this._routes);
     return this;
   }
   /**
@@ -2340,6 +2222,10 @@ exports.Platform = class Platform {
   getMountedControllers() {
     return this._controllers;
   }
+
+  $onInit() {
+    this.buildControllers();
+  }
   /**
    * Create routers from the collected controllers.
    * @private
@@ -2370,38 +2256,6 @@ exports.Platform = class Platform {
       }
     });
   }
-  /**
-   *
-   * @param ctrl
-   * @param endpointUrl
-   */
-
-
-  buildRoutes(endpointUrl, ctrl) {
-    const {
-      injector
-    } = this;
-    let routes = [];
-    routes = ctrl.children.map(ctrl => injector.getProvider(ctrl)).reduce((routes, provider) => {
-      return routes.concat(this.buildRoutes(`${endpointUrl}${provider.path}`, provider));
-    }, routes);
-    ctrl.endpoints.forEach(endpoint => {
-      endpoint.operationPaths.forEach(({
-        path,
-        method
-      }) => {
-        if (method) {
-          routes.push(new PlatformRouteDetails({
-            provider: ctrl,
-            endpoint,
-            method,
-            url: `${endpointUrl}${path || ""}`.replace(/\/\//gi, "/")
-          }));
-        }
-      });
-    });
-    return routes;
-  }
 
 };
 exports.Platform = tslib.__decorate([di.Injectable({
@@ -3165,16 +3019,6 @@ function MultipartFile(name, maxCount) {
   };
 }
 
-/**
- *
- * @param fn
- * @decorator
- */
-
-function EndpointFn(fn) {
-  return schema.JsonEntityFn(fn);
-}
-
 /**
  * Set a mime list which are acceptable and checks if the specified content types are acceptable, based on the request’s Accept HTTP header field.
  *
@@ -3195,9 +3039,18 @@ function EndpointFn(fn) {
  */
 
 function AcceptMime(...mimes) {
-  return core.useDecorators(schema.Produces(...mimes), EndpointFn(endpoint => {
-    endpoint.acceptMimes = mimes;
-  }));
+  return core.useDecorators(schema.Produces(...mimes), core.StoreSet("acceptMimes", mimes));
+}
+
+/**
+ *
+ * @param fn
+ * @decorator
+ * @deprecated Deprecated since 2021-10-05. Use JsonEntityFn instead.
+ */
+
+function EndpointFn(fn) {
+  return schema.JsonEntityFn(fn);
 }
 
 /**
@@ -3570,13 +3423,6 @@ class PlatformTest extends di.DITest {
 
 }
 
-di.GlobalProviders.createRegistry(di.ProviderType.CONTROLLER, ControllerProvider, {
-  onInvoke(provider, locals) {
-    locals.set(exports.PlatformRouter, provider.getRouter());
-  }
-
-});
-
 /**
  * @ignore
  * @deprecated Will be removed in v7