@tsed/platform-router 8.0.1 → 8.0.3

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/platform-router",
   "description": "Router",
   "type": "module",
-  "version": "8.0.1",
+  "version": "8.0.3",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -25,25 +26,25 @@
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.1",
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/platform-params": "8.0.1",
-    "@tsed/schema": "8.0.1",
-    "@tsed/typescript": "8.0.1",
+    "@tsed/barrels": "8.0.3",
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/exceptions": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
+    "@tsed/platform-params": "8.0.3",
+    "@tsed/schema": "8.0.3",
+    "@tsed/typescript": "8.0.3",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.1",
-    "@tsed/di": "8.0.1",
-    "@tsed/exceptions": "8.0.1",
-    "@tsed/json-mapper": "8.0.1",
-    "@tsed/platform-params": "8.0.1",
-    "@tsed/schema": "8.0.1"
+    "@tsed/core": "8.0.3",
+    "@tsed/di": "8.0.3",
+    "@tsed/exceptions": "8.0.3",
+    "@tsed/json-mapper": "8.0.3",
+    "@tsed/platform-params": "8.0.3",
+    "@tsed/schema": "8.0.3"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/src/domain/PlatformHandlerMetadata.spec.ts

@@ -0,0 +1,149 @@
+import {Controller, destroyInjector, injector} from "@tsed/di";
+import {Err, Next, Req} from "@tsed/platform-http";
+import {Middleware} from "@tsed/platform-middlewares";
+import {Get, JsonMethodStore} from "@tsed/schema";
+
+import {useContextHandler} from "../utils/useContextHandler.js";
+import {PlatformHandlerMetadata} from "./PlatformHandlerMetadata.js";
+import {PlatformHandlerType} from "./PlatformHandlerType.js";
+
+describe("PlatformHandlerMetadata", () => {
+  afterEach(() => destroyInjector());
+  describe("from()", () => {
+    it("should return PlatformMetadata", () => {
+      const meta = new PlatformHandlerMetadata({
+        type: PlatformHandlerType.CUSTOM,
+        handler: () => {}
+      });
+      const result = PlatformHandlerMetadata.from(meta);
+      expect(result).toEqual(meta);
+    });
+  });
+  describe("from useContextHandler", () => {
+    it("should create a new handlerMetadata with right metadata", () => {
+      // GIVEN
+      const handler = useContextHandler((ctx: any) => {});
+
+      // WHEN
+      const handlerMetadata = new PlatformHandlerMetadata({
+        handler
+      });
+
+      // THEN
+      expect(handlerMetadata.type).toEqual(PlatformHandlerType.CTX_FN);
+      expect(handlerMetadata.hasNextFunction).toEqual(false);
+      expect(handlerMetadata.hasErrorParam).toEqual(false);
+      expect(handlerMetadata.toString()).toEqual("");
+    });
+  });
+  describe("from function", () => {
+    it("should create a new handlerMetadata with right metadata", () => {
+      // GIVEN
+      const options = {
+        handler(req: any, res: any, next: any) {}
+      };
+      // WHEN
+      const handlerMetadata = new PlatformHandlerMetadata(options);
+
+      // THEN
+      expect(handlerMetadata.type).toEqual(PlatformHandlerType.RAW_FN);
+      expect(handlerMetadata.hasNextFunction).toEqual(true);
+      expect(handlerMetadata.hasErrorParam).toEqual(false);
+      expect(handlerMetadata.toString()).toEqual("handler");
+    });
+  });
+  describe("from function err", () => {
+    it("should create a new handlerMetadata with right metadata", () => {
+      // GIVEN
+      const options = {
+        handler(err: any, req: any, res: any, next: any) {}
+      };
+      // WHEN
+      const handlerMetadata = new PlatformHandlerMetadata(options);
+
+      // THEN
+      expect(handlerMetadata.type).toEqual(PlatformHandlerType.RAW_ERR_FN);
+      expect(handlerMetadata.hasNextFunction).toEqual(true);
+      expect(handlerMetadata.hasErrorParam).toEqual(true);
+      expect(handlerMetadata.propertyKey).toBeUndefined();
+      expect(handlerMetadata.toString()).toEqual("handler");
+    });
+  });
+  describe("from function without nextFn", () => {
+    it("should create a new handlerMetadata with right metadata", () => {
+      // GIVEN
+      const options = {
+        handler(req: any, res: any) {}
+      };
+
+      // WHEN
+      const handlerMetadata = new PlatformHandlerMetadata(options);
+
+      // THEN
+      expect(handlerMetadata.type).toEqual(PlatformHandlerType.RAW_FN);
+      expect(handlerMetadata.hasNextFunction).toEqual(false);
+      expect(handlerMetadata.hasErrorParam).toEqual(false);
+      expect(handlerMetadata.propertyKey).toBeUndefined();
+      expect(handlerMetadata.toString()).toEqual("handler");
+    });
+  });
+  describe("from endpoint/middleware with injection", () => {
+    it("should create a new handlerMetadata with right metadata", () => {
+      // GIVEN
+      @Controller("/")
+      class Test {
+        @Get("/")
+        test(@Req() req: Req, @Next() next: Next) {}
+      }
+
+      injector().addProvider(Test);
+
+      const options = {
+        provider: injector().getProvider(Test),
+        propertyKey: "test",
+        type: PlatformHandlerType.ENDPOINT
+      };
+      // WHEN
+      const handlerMetadata = new PlatformHandlerMetadata(options);
+
+      // THEN
+      expect(handlerMetadata.type).toEqual(PlatformHandlerType.ENDPOINT);
+      expect(handlerMetadata.hasNextFunction).toEqual(true);
+      expect(handlerMetadata.hasErrorParam).toEqual(false);
+      expect(handlerMetadata.propertyKey).toEqual("test");
+      expect(handlerMetadata.scope).toEqual("singleton");
+      expect(handlerMetadata.toString()).toEqual("Test.test");
+      expect(handlerMetadata.store).toBeInstanceOf(JsonMethodStore);
+
+      expect(handlerMetadata.getParams()[0].paramType).toEqual("REQUEST");
+      expect(handlerMetadata.getParams()[1].paramType).toEqual("NEXT_FN");
+    });
+  });
+
+  describe("from middleware with injection and error", () => {
+    it("should create a new handlerMetadata with right metadata", () => {
+      // WHEN
+      @Middleware()
+      class Test {
+        use(@Err() error: any, @Next() next: Next) {}
+      }
+
+      injector().addProvider(Test);
+
+      const options = {
+        provider: injector().getProvider(Test),
+        propertyKey: "use",
+        type: PlatformHandlerType.MIDDLEWARE
+      };
+      // WHEN
+      const handlerMetadata = new PlatformHandlerMetadata(options);
+
+      // THEN
+      expect(handlerMetadata.type).toEqual(PlatformHandlerType.ERR_MIDDLEWARE);
+      expect(handlerMetadata.hasNextFunction).toEqual(true);
+      expect(handlerMetadata.hasErrorParam).toEqual(true);
+      expect(handlerMetadata.propertyKey).toEqual("use");
+      expect(handlerMetadata.toString()).toEqual("Test.use");
+    });
+  });
+});

package/src/domain/PlatformHandlerMetadata.ts

@@ -0,0 +1,145 @@
+import {nameOf} from "@tsed/core";
+import {DIContext, injector, Provider, ProviderScope, TokenProvider} from "@tsed/di";
+import {ParamTypes} from "@tsed/platform-params";
+import {EndpointMetadata, JsonEntityStore, JsonParameterStore} from "@tsed/schema";
+
+import {PlatformHandlerType} from "./PlatformHandlerType.js";
+import {SinglePathType} from "./SinglePathType.js";
+
+export interface PlatformHandlerMetadataOpts extends Record<string, any> {
+  token?: TokenProvider;
+}
+
+export interface PlatformHandlerMetadataProps {
+  provider?: Provider;
+  handler?: any;
+  opts?: PlatformHandlerMetadataOpts;
+  propertyKey?: string | symbol;
+  type?: PlatformHandlerType;
+}
+
+export class PlatformHandlerMetadata {
+  path: SinglePathType;
+
+  readonly provider?: Provider;
+  readonly propertyKey: string | symbol;
+  readonly type: PlatformHandlerType = PlatformHandlerType.RAW_FN;
+  readonly hasNextFunction: boolean = false;
+  readonly opts: PlatformHandlerMetadataOpts = {};
+  compiledHandler: ($ctx: DIContext) => any;
+  #handler: any;
+
+  constructor(props: PlatformHandlerMetadataProps) {
+    const {propertyKey, type, provider, handler, opts} = props;
+
+    this.provider = provider;
+    this.type = type || handler.type || PlatformHandlerType.RAW_FN;
+    this.opts = opts || {};
+
+    this.#handler = propertyKey ? this.target.prototype[propertyKey] : handler;
+
+    if (propertyKey) {
+      this.propertyKey = propertyKey;
+      this.hasNextFunction = this.hasParamType(ParamTypes.NEXT_FN);
+
+      if (this.hasParamType(ParamTypes.ERR)) {
+        this.type = PlatformHandlerType.ERR_MIDDLEWARE;
+      }
+    } else {
+      if (this.#handler.length === 4) {
+        this.type = PlatformHandlerType.RAW_ERR_FN;
+      }
+      this.hasNextFunction = this.#handler.length >= 3;
+    }
+  }
+
+  get target() {
+    return this.provider?.useClass || this.#handler;
+  }
+
+  get token() {
+    return this.provider?.token || this.#handler;
+  }
+
+  get handler() {
+    return this.#handler;
+  }
+
+  get scope() {
+    return this.provider?.scope || ProviderScope.SINGLETON;
+  }
+
+  get hasErrorParam() {
+    return this.type === PlatformHandlerType.ERR_MIDDLEWARE || this.type === PlatformHandlerType.RAW_ERR_FN;
+  }
+
+  get store() {
+    return JsonEntityStore.fromMethod(this.provider!.useClass, this.propertyKey!);
+  }
+
+  static from(input: any, opts: PlatformHandlerMetadataOpts = {}): PlatformHandlerMetadata {
+    if (input instanceof PlatformHandlerMetadata) {
+      return input;
+    }
+
+    if (input instanceof EndpointMetadata) {
+      const provider = injector().getProvider(opts.token)!;
+
+      return new PlatformHandlerMetadata({
+        provider,
+        type: PlatformHandlerType.ENDPOINT,
+        propertyKey: input.propertyKey,
+        opts
+      });
+    }
+
+    const provider = injector().getProvider(input);
+
+    if (provider) {
+      return new PlatformHandlerMetadata({
+        provider,
+        type: PlatformHandlerType.MIDDLEWARE,
+        propertyKey: "use",
+        opts
+      });
+    }
+
+    return new PlatformHandlerMetadata({
+      handler: input,
+      type: input.type,
+      opts
+    });
+  }
+
+  public getParams() {
+    return JsonParameterStore.getParams(this.target, this.propertyKey) || [];
+  }
+
+  public hasParamType(paramType: any): boolean {
+    return this.getParams().findIndex((p) => p.paramType === paramType) > -1;
+  }
+
+  public isInjectable() {
+    return !(this.isRawFn() || this.isResponseFn());
+  }
+
+  public isRawFn() {
+    return this.type === PlatformHandlerType.RAW_ERR_FN || this.type === PlatformHandlerType.RAW_FN;
+  }
+
+  public isEndpoint() {
+    return this.type === PlatformHandlerType.ENDPOINT;
+  }
+
+  public isCtxFn() {
+    return this.type === PlatformHandlerType.CTX_FN;
+  }
+
+  public isResponseFn() {
+    return this.type === PlatformHandlerType.RESPONSE_FN;
+  }
+
+  toString() {
+    return [nameOf(this.target), this.propertyKey].filter(Boolean).join(".");
+  }
+}

package/src/domain/PlatformHandlerType.ts

@@ -0,0 +1,10 @@
+export enum PlatformHandlerType {
+  CUSTOM = "custom",
+  ENDPOINT = "endpoint",
+  MIDDLEWARE = "middleware",
+  ERR_MIDDLEWARE = "err:middleware",
+  CTX_FN = "context",
+  RESPONSE_FN = "response",
+  RAW_FN = "raw:middleware",
+  RAW_ERR_FN = "raw:err:middleware"
+}

package/src/domain/PlatformLayer.ts

@@ -0,0 +1,89 @@
+import {isPrimitive, nameOf, Type} from "@tsed/core";
+import {Provider} from "@tsed/di";
+import type {PlatformParamsCallback} from "@tsed/platform-params";
+import {concatPath} from "@tsed/schema";
+
+import {PlatformHandlerMetadata} from "./PlatformHandlerMetadata.js";
+import type {PlatformRouter} from "./PlatformRouter.js";
+import {SinglePathType} from "./SinglePathType.js";
+
+export interface PlatformLayerOptions extends Record<string, any> {
+  token?: Type<any>;
+}
+
+export interface PlatformLayerProps {
+  parent: PlatformLayer;
+  provider: Provider;
+  path: SinglePathType;
+  basePath: SinglePathType;
+  method: string;
+  handlers: any[];
+  router: PlatformRouter;
+  opts: PlatformLayerOptions;
+}
+
+export class PlatformLayer {
+  public provider: Provider;
+  public path: SinglePathType = "";
+  public method: string;
+  public handlers: PlatformHandlerMetadata[] = [];
+  public router?: PlatformRouter;
+  public opts: PlatformLayerOptions = {};
+
+  public layers: PlatformLayer[] = [];
+
+  public parent?: PlatformLayer;
+  basePath: SinglePathType;
+  #args: PlatformParamsCallback[];
+
+  constructor(props: Partial<PlatformLayerProps> = {}) {
+    Object.assign(this, props);
+
+    this.layers = this.layers.map((layer) => {
+      return new PlatformLayer({
+        ...layer,
+        parent: this
+      });
+    });
+  }
+
+  set(args: PlatformParamsCallback[]) {
+    this.#args = args;
+  }
+
+  getArgs() {
+    return [this.path, ...this.#args].filter(Boolean);
+  }
+
+  isProvider() {
+    return !!this.provider;
+  }
+
+  inspect() {
+    return {
+      basePath: this.getBasePath(),
+      path: this.path,
+      method: this.method,
+      handlers: this.handlers.map((item: any) => String(item)),
+      opts: Object.entries(this.opts).reduce((obj, [key, value]) => {
+        return {
+          ...obj,
+          [key]: isPrimitive(value) ? value : nameOf(value)
+        };
+      }, {})
+    };
+  }
+
+  getBasePath(): string {
+    return concatPath(this.parent?.getBasePath(), this.basePath);
+  }
+
+  setLayers(layers: PlatformLayer[]) {
+    this.layers = layers.map((layer) => {
+      return new PlatformLayer({
+        ...layer,
+        parent: this
+      });
+    });
+  }
+}

package/src/domain/PlatformRouter.ts

@@ -0,0 +1,131 @@
+import {isString} from "@tsed/core";
+import {injectable, Provider, ProviderScope} from "@tsed/di";
+import {concatPath} from "@tsed/schema";
+
+import {formatMethod} from "../utils/formatMethod.js";
+import {PlatformHandlerMetadata} from "./PlatformHandlerMetadata.js";
+import {PlatformLayer, PlatformLayerOptions} from "./PlatformLayer.js";
+import {SinglePathType} from "./SinglePathType.js";
+
+function printHandler(handler: any) {
+  return handler.toString().split("{")[0].trim();
+}
+
+export class PlatformRouter {
+  readonly layers: PlatformLayer[] = [];
+  provider: Provider;
+  #isBuilt = false;
+
+  use(...handlers: any[]) {
+    const layer = handlers.reduce(
+      (layer: PlatformLayer, item) => {
+        if (isString(item) || item instanceof RegExp) {
+          layer.path = item;
+          layer.basePath = item;
+        } else {
+          if (item instanceof PlatformRouter) {
+            layer.router = item;
+            layer.setLayers(item.layers);
+
+            if (!this.provider && item.provider) {
+              layer.path = concatPath(layer.path, item.provider.path);
+            } else {
+              layer.path = layer.path || item.provider.path;
+            }
+          } else {
+            item = PlatformHandlerMetadata.from(item);
+          }
+
+          layer.handlers.push(item);
+        }
+
+        return layer;
+      },
+      new PlatformLayer({
+        method: "use",
+        basePath: this.provider?.path || "/",
+        provider: this.provider
+      })
+    );
+
+    this.layers.push(layer);
+
+    return this;
+  }
+
+  addRoute(method: string, path: SinglePathType, handlers: any[], opts: PlatformLayerOptions = {}) {
+    const layer = new PlatformLayer({
+      provider: this.provider,
+      method: formatMethod(method),
+      path,
+      handlers: handlers.map((input) => {
+        return PlatformHandlerMetadata.from(input, opts);
+      }),
+      opts
+    });
+
+    this.layers.push(layer);
+
+    return this;
+  }
+
+  all(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("all", path, handlers);
+  }
+
+  get(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("get", path, handlers);
+  }
+
+  post(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("post", path, handlers);
+  }
+
+  put(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("put", path, handlers);
+  }
+
+  delete(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("delete", path, handlers);
+  }
+
+  patch(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("patch", path, handlers);
+  }
+
+  head(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("head", path, handlers);
+  }
+
+  options(path: SinglePathType, ...handlers: any[]) {
+    return this.addRoute("options", path, handlers);
+  }
+
+  statics(path: string, options: any) {
+    return this.addRoute("statics", path, [], options);
+  }
+
+  inspect() {
+    return this.layers.map((layer) => {
+      const obj = layer.inspect();
+
+      return {
+        ...obj,
+        handlers: obj.handlers.map(printHandler),
+        path: concatPath(this.provider?.path, obj.path)
+      };
+    });
+  }
+
+  isBuilt() {
+    if (this.#isBuilt) {
+      return true;
+    }
+
+    this.#isBuilt = true;
+
+    return false;
+  }
+}
+
+injectable(PlatformRouter).scope(ProviderScope.INSTANCE);

package/src/domain/PlatformRouters.ts

@@ -0,0 +1,196 @@
+import {getValue, Type} from "@tsed/core";
+import {
+  constant,
+  ControllerProvider,
+  inject,
+  injectable,
+  injector,
+  Provider,
+  ProviderType,
+  ResolvedInvokeOptions,
+  TokenProvider
+} from "@tsed/di";
+import {$on, Hooks} from "@tsed/hooks";
+import {PlatformParamsCallback} from "@tsed/platform-params";
+import {concatPath, getOperationsRoutes, JsonMethodStore, OPERATION_HTTP_VERBS} from "@tsed/schema";
+
+import {useContextHandler} from "../utils/useContextHandler.js";
+import {PlatformHandlerMetadata} from "./PlatformHandlerMetadata.js";
+import {PlatformLayer} from "./PlatformLayer.js";
+import {PlatformRouter} from "./PlatformRouter.js";
+
+let AUTO_INC = 0;
+
+function getInjectableRouter(provider: Provider): PlatformRouter {
+  return injector().get(provider.tokenRouter)!;
+}
+
+function createTokenRouter(provider: ControllerProvider) {
+  return (provider.tokenRouter = provider.tokenRouter || `${provider.name}_ROUTER_${AUTO_INC++}`);
+}
+
+function createInjectableRouter(provider: ControllerProvider): PlatformRouter {
+  const tokenRouter = createTokenRouter(provider);
+
+  if (injector().has(tokenRouter)) {
+    return getInjectableRouter(provider);
+  }
+
+  const router = inject<PlatformRouter>(PlatformRouter);
+  router.provider = provider;
+
+  return injector()
+    .add(tokenRouter, {
+      useValue: router
+    })
+    .invoke<PlatformRouter>(tokenRouter);
+}
+
+export interface AlterEndpointHandlersArg {
+  before: (Type<any> | Function)[];
+  endpoint: JsonMethodStore;
+  after: (Type<any> | Function)[];
+}
+
+export class PlatformRouters {
+  readonly hooks = new Hooks();
+  readonly allowedVerbs = OPERATION_HTTP_VERBS;
+
+  prebuild() {
+    injector()
+      .getProviders(ProviderType.CONTROLLER)
+      .forEach((provider: ControllerProvider) => {
+        createInjectableRouter(provider);
+      });
+  }
+
+  from(token: TokenProvider, parentMiddlewares: any[] = []) {
+    const provider = injector().getProvider<ControllerProvider>(token)!;
+
+    if (!provider) {
+      throw new Error("Token not found in the provider registry");
+    }
+
+    const router = createInjectableRouter(provider);
+
+    if (router.isBuilt()) {
+      return router;
+    }
+
+    const useBefore = getValue(provider, "middlewares.useBefore", []);
+    const middlewares: any[] = [...parentMiddlewares, ...useBefore];
+    const {children} = provider;
+
+    // Set default to true in next major version
+    const appendChildrenRoutesFirst = constant<boolean>("router.appendChildrenRoutesFirst", false);
+
+    if (appendChildrenRoutesFirst) {
+      children.forEach((token: Type<any>) => {
+        const nested = this.from(token, middlewares);
+        router.use(nested);
+      });
+    }
+
+    getOperationsRoutes(provider.token, {allowedVerbs: this.allowedVerbs}).forEach((operationRoute) => {
+      const {endpoint} = operationRoute;
+      const {beforeMiddlewares, middlewares: mldwrs, afterMiddlewares} = endpoint;
+
+      const useBefore = getValue(provider, "middlewares.useBefore", []);
+      const use = getValue(provider, "middlewares.use", []);
+      const useAfter = getValue(provider, "middlewares.useAfter", []);
+
+      let handlers = this.hooks.alter<AlterEndpointHandlersArg>(
+        "alterEndpointHandlers",
+        {
+          before: [...parentMiddlewares, ...useBefore, ...beforeMiddlewares, ...use, ...mldwrs],
+          endpoint,
+          after: [...afterMiddlewares, ...useAfter]
+        },
+        [operationRoute],
+        this
+      );
+
+      handlers = this.sortHandlers(handlers);
+
+      router.addRoute(
+        operationRoute.method,
+        operationRoute.path || "",
+        [
+          useContextHandler(($ctx) => {
+            $ctx.endpoint = operationRoute.endpoint;
+          }),
+          ...[...handlers.before, handlers.endpoint, ...handlers.after]
+        ],
+        operationRoute
+      );
+    });
+
+    if (!appendChildrenRoutesFirst) {
+      children.forEach((token: Type<any>) => {
+        const nested = this.from(token, middlewares);
+        router.use(nested);
+      });
+    }
+
+    return router;
+  }
+
+  getLayers(router: PlatformRouter): PlatformLayer[] {
+    return this.flatMapLayers(router.layers);
+  }
+
+  private sortHandlers(handlers: AlterEndpointHandlersArg) {
+    const get = (token: TokenProvider) => {
+      return injector().getProvider(token)?.priority || 0;
+    };
+
+    const sort = (p1: TokenProvider, p2: TokenProvider) => (get(p1) < get(p2) ? -1 : get(p1) > get(p2) ? 1 : 0);
+
+    handlers.before = handlers.before.sort(sort);
+    handlers.after = handlers.after.sort(sort);
+
+    return handlers;
+  }
+
+  private flatMapLayers(layers: PlatformLayer[]): PlatformLayer[] {
+    return layers
+      .flatMap((layer) => {
+        if (layer.router) {
+          return this.flatMapLayers(layer.layers).map((subLayer: PlatformLayer) => {
+            return new PlatformLayer({
+              ...subLayer,
+              path: concatPath(layer.path, subLayer.path)
+            });
+          });
+        }
+
+        return new PlatformLayer(layer);
+      })
+      .map((layer) => {
+        const handlers = layer.handlers.map((handlerMetadata) => {
+          // set path on handler metadata to retrieve it later in $ctx
+          handlerMetadata.path = layer.path;
+
+          if (handlerMetadata.isRawFn()) {
+            return handlerMetadata.handler;
+          }
+
+          return this.hooks.alter<PlatformHandlerMetadata, PlatformParamsCallback>("alterHandler", handlerMetadata);
+        });
+
+        layer.set(handlers);
+
+        return layer;
+      });
+  }
+}
+
+injectable(PlatformRouters);
+/**
+ * Create injectable router for the current invoked provider.
+ * @ignore
+ */
+$on(`$beforeInvoke:${ProviderType.CONTROLLER}`, ({provider, locals}: ResolvedInvokeOptions) => {
+  const router = createInjectableRouter(provider as ControllerProvider);
+  locals.set(PlatformRouter, router);
+});

package/src/domain/SinglePathType.ts

@@ -0,0 +1 @@
+export type SinglePathType = string | RegExp;

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./domain/PlatformHandlerMetadata.js";
+export * from "./domain/PlatformHandlerType.js";
+export * from "./domain/PlatformLayer.js";
+export * from "./domain/PlatformRouter.js";
+export * from "./domain/PlatformRouters.js";
+export * from "./domain/SinglePathType.js";
+export * from "./utils/formatMethod.js";
+export * from "./utils/useContextHandler.js";

package/src/utils/formatMethod.ts

@@ -0,0 +1,5 @@
+import {OperationVerbs} from "@tsed/schema";
+
+export function formatMethod(method: string | undefined) {
+  return (method === OperationVerbs.CUSTOM ? "use" : method || "use").toLowerCase();
+}

package/src/utils/useContextHandler.ts

@@ -0,0 +1,22 @@
+import {DIContext} from "@tsed/di";
+
+import {PlatformHandlerType} from "../domain/PlatformHandlerType.js";
+
+export type PlatformContextHandler<Context = DIContext> = ($ctx: Context) => any | Promise<any>;
+
+/**
+ * Create Ts.ED context handler
+ * @param fn
+ * @ignore
+ */
+export function useContextHandler(fn: PlatformContextHandler & {type?: PlatformHandlerType}) {
+  fn.type = PlatformHandlerType.CTX_FN;
+
+  return fn;
+}
+
+export function useResponseHandler(fn: PlatformContextHandler & {type?: PlatformHandlerType}) {
+  fn.type = PlatformHandlerType.RESPONSE_FN;
+
+  return fn;
+}