@tsed/platform-http 8.0.1 → 8.0.3

package/src/common/domain/AnyToPromiseWithCtx.ts

@@ -0,0 +1,30 @@
+import {AnyPromiseResult, AnyToPromise} from "@tsed/core";
+
+import {PlatformContext} from "./PlatformContext.js";
+
+export class AnyToPromiseWithCtx extends AnyToPromise {
+  public $ctx: PlatformContext;
+
+  constructor($ctx: PlatformContext) {
+    super();
+    this.$ctx = $ctx;
+  }
+
+  isDone(): boolean {
+    const {$ctx} = this;
+
+    return $ctx?.isDone() || super.isDone();
+  }
+
+  call(cb: Function): Promise<AnyPromiseResult<any>> {
+    return super.call(() => cb(this));
+  }
+
+  destroy() {
+    (this.$ctx as any) = null;
+  }
+
+  isCanceledResponse(process: any) {
+    return process === this.$ctx.getResponse();
+  }
+}

package/src/common/domain/EndpointMetadata.ts

@@ -0,0 +1 @@
+export {EndpointMetadata} from "@tsed/schema";

package/src/common/domain/PlatformContext.spec.ts

@@ -0,0 +1,124 @@
+import {nameOf} from "@tsed/core";
+
+import {PlatformTest} from "../../testing/PlatformTest.js";
+import {PlatformApplication} from "../services/PlatformApplication.js";
+import {PlatformContext} from "./PlatformContext.js";
+
+describe("PlatformContext", () => {
+  beforeEach(() => PlatformTest.create());
+  afterEach(() => PlatformTest.reset());
+  it("should create a new Context and skip log", () => {
+    const logger = {
+      info: vi.fn()
+    };
+    const context = new PlatformContext({
+      event: {
+        response: PlatformTest.createResponse(),
+        request: PlatformTest.createRequest({
+          url: "/admin"
+        })
+      },
+      id: "id",
+      logger,
+      maxStackSize: 0,
+      ignoreUrlPatterns: ["/admin", /\/admin2/],
+      injector: PlatformTest.injector
+    });
+
+    context.endpoint = {} as any;
+    context.logger.info("test");
+
+    context.handlerMetadata = {} as any;
+    context.endpoint = {} as any;
+
+    expect(context.id).toEqual("id");
+    expect(context.dateStart).toBeInstanceOf(Date);
+    expect(context.container).toBeInstanceOf(Map);
+    expect(context.env).toEqual("test");
+    expect(context.getRequest()).toEqual(context.request.raw);
+    expect(context.getResponse()).toEqual(context.response.raw);
+    expect(context.getReq()).toEqual(context.request.raw);
+    expect(context.getRes()).toEqual(context.response.raw);
+    expect(context.app).toBeInstanceOf(PlatformApplication);
+    expect(context.handlerMetadata).toEqual({});
+    expect(context.endpoint).toEqual({});
+    expect(nameOf(context.getApp())).toEqual("FakeRawDriver");
+  });
+  it("should create a new Context and log event", () => {
+    const logger = {
+      info: vi.fn()
+    };
+
+    const context = new PlatformContext({
+      id: "id",
+      event: {
+        response: PlatformTest.createResponse(),
+        request: PlatformTest.createRequest({
+          url: "/"
+        })
+      },
+      logger,
+      injector: PlatformTest.injector,
+      maxStackSize: 0,
+      ignoreUrlPatterns: ["/admin", /\/admin2/]
+    });
+
+    context.logger.info("test");
+
+    expect(context.id).toEqual("id");
+    expect(context.dateStart).toBeInstanceOf(Date);
+    expect(context.container).toBeInstanceOf(Map);
+    expect(context.env).toEqual("test");
+    expect(context.app).toBeInstanceOf(PlatformApplication);
+    expect(nameOf(context.getApp())).toEqual("FakeRawDriver");
+  });
+  it("should return done when the response is empty", async () => {
+    const context = new PlatformContext({
+      id: "id",
+      event: {
+        response: PlatformTest.createResponse(),
+        request: PlatformTest.createRequest({
+          url: "/"
+        })
+      },
+      logger: {
+        info: vi.fn()
+      },
+      injector: PlatformTest.injector,
+      maxStackSize: 0,
+      ignoreUrlPatterns: ["/admin"]
+    });
+
+    expect(context.isDone()).toEqual(false);
+
+    await context.finish();
+
+    expect(context.isDone()).toEqual(true);
+  });
+  it("should return done when the response is empty (start context before)", async () => {
+    // @ts-ignore
+    const context = new PlatformContext({
+      id: "id",
+      event: {
+        response: PlatformTest.createResponse(),
+        request: PlatformTest.createRequest({
+          url: "/"
+        })
+      },
+      logger: {
+        info: vi.fn()
+      },
+      injector: PlatformTest.injector,
+      maxStackSize: 0,
+      ignoreUrlPatterns: ["/admin"]
+    });
+
+    await context.start();
+
+    expect(context.isDone()).toEqual(false);
+
+    await context.finish();
+
+    expect(context.isDone()).toEqual(true);
+  });
+});

package/src/common/domain/PlatformContext.ts

@@ -0,0 +1,135 @@
+import {DIContext, DIContextOptions, injector} from "@tsed/di";
+import {$asyncEmit} from "@tsed/hooks";
+import {PlatformHandlerMetadata} from "@tsed/platform-router";
+import {EndpointMetadata} from "@tsed/schema";
+import {IncomingMessage, ServerResponse} from "http";
+
+import {IncomingEvent} from "../interfaces/IncomingEvent.js";
+import {PlatformApplication} from "../services/PlatformApplication.js";
+import {PlatformRequest} from "../services/PlatformRequest.js";
+import {PlatformResponse} from "../services/PlatformResponse.js";
+
+declare global {
+  namespace TsED {
+    export interface Context extends PlatformContext {}
+  }
+}
+
+export interface PlatformContextOptions extends DIContextOptions {
+  event: IncomingEvent;
+  ignoreUrlPatterns?: any[];
+  endpoint?: EndpointMetadata;
+}
+
+export class PlatformContext<
+  PReq extends PlatformRequest = PlatformRequest,
+  PRes extends PlatformResponse = PlatformResponse
+> extends DIContext {
+  readonly PLATFORM: string = "WWW";
+  public event: IncomingEvent;
+  /**
+   * The data return by the previous endpoint if you use multiple handler on the same route. By default data is empty.
+   */
+  public data: any;
+  /**
+   * The error caught by the current handler
+   */
+  public error?: unknown;
+  /**
+   *
+   */
+  public next?: any;
+  /**
+   * The current @@PlatformResponse@@.
+   */
+  readonly response: PRes;
+  /**
+   * The current @@PlatformRequest@@.
+   */
+  readonly request: PReq;
+  /**
+   * The current @@EndpointMetadata@@ resolved by Ts.ED during the request.
+   */
+  endpoint: EndpointMetadata;
+  /**
+   * The current @@PlatformHandlerMetadata@@ resolved by Ts.ED during the request.
+   */
+  handlerMetadata: PlatformHandlerMetadata;
+
+  #isFinished: boolean = false;
+
+  constructor(options: PlatformContextOptions) {
+    super(options);
+
+    options.endpoint && (this.endpoint = options.endpoint);
+
+    this.event = options.event;
+    this.response = new (options.ResponseKlass || PlatformResponse)(this);
+    this.request = new (options.RequestKlass || PlatformRequest)(this);
+
+    this.request.request.$ctx = this;
+    this.request.request.id = this.id;
+
+    this.response.setHeader("x-request-id", this.id);
+  }
+
+  get url() {
+    return this.request.url;
+  }
+
+  get app() {
+    return injector().get<PlatformApplication>(PlatformApplication)!;
+  }
+
+  start() {
+    return $asyncEmit("$onRequest", [this]);
+  }
+
+  async finish() {
+    await Promise.all([$asyncEmit("$onResponse", [this]), this.destroy()]);
+    this.#isFinished = true;
+  }
+
+  isFinished() {
+    return this.#isFinished;
+  }
+
+  isDone() {
+    return this.request?.isAborted() || this.response?.isDone() || this.isFinished();
+  }
+
+  /**
+   * Return the framework request instance (Express, Koa, etc...)
+   */
+  getRequest<Req = any>(): Req {
+    return this.request.getRequest<Req>();
+  }
+
+  /**
+   * Return the framework response instance (Express, Koa, etc...)
+   */
+  getResponse<Res = any>(): Res {
+    return this.response.getResponse<Res>();
+  }
+
+  /**
+   * Get Node.js request
+   */
+  getReq(): IncomingMessage {
+    return this.request.getReq();
+  }
+
+  /**
+   * Get Node.js response
+   */
+  getRes(): ServerResponse {
+    return this.response.getRes();
+  }
+
+  /**
+   * Return the original application instance.
+   */
+  getApp<T = any>(): T {
+    return this.app.getApp() as any;
+  }
+}

package/src/common/domain/PlatformRouteDetails.ts

@@ -0,0 +1,7 @@
+export interface PlatformRouteDetails {
+  method: string;
+  name: string;
+  url: string;
+  className: string;
+  methodClassName: string;
+}

package/src/common/exports.ts

@@ -0,0 +1,4 @@
+import "@tsed/logger";
+import "@tsed/platform-exceptions";
+import "@tsed/platform-response-filter";
+import "@tsed/platform-router";

package/src/common/fn/adapter.ts

@@ -0,0 +1,23 @@
+import {Type} from "@tsed/core";
+import {refValue} from "@tsed/di";
+
+import type {PlatformAdapter} from "../services/PlatformAdapter.js";
+
+const ADAPTER = "platform.adapter";
+
+let globalAdapter: Type<PlatformAdapter<any>>;
+
+/**
+ * Set the platform adapter
+ */
+export function adapter(adapter?: Type<PlatformAdapter<any>>): Type<PlatformAdapter<any>> {
+  const ref = refValue<Type<PlatformAdapter<any>>>(ADAPTER);
+
+  if (adapter) {
+    globalAdapter ||= adapter;
+  }
+
+  ref.value ||= globalAdapter;
+
+  return ref.value as Type<PlatformAdapter<any>>;
+}

package/src/common/fn/application.ts

@@ -0,0 +1,11 @@
+import {injector} from "@tsed/di";
+
+import type {PlatformApplication} from "../services/PlatformApplication.js";
+
+/**
+ * Return the injectable Application instance.
+ * @note Application is only available after PlatformExpress/PlatformKoa instance creation.
+ */
+export function application<App = TsED.Application>() {
+  return injector().get<PlatformApplication<App>>("PlatformApplication")!;
+}

package/src/common/index.ts

@@ -0,0 +1,62 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./builder/PlatformBuilder.js";
+export * from "./config/interfaces/PlatformJsonMapperSettings.js";
+export * from "./config/interfaces/PlatformMulterSettings.js";
+export * from "./config/interfaces/PlatformRouterSettings.js";
+export * from "./config/interfaces/PlatformStaticsSettings.js";
+export * from "./config/services/PlatformConfiguration.js";
+export * from "./constants/routerOptions.js";
+export * from "./decorators/multer/multerFileSize.js";
+export * from "./decorators/multer/multerOptions.js";
+export * from "./decorators/multer/multipartFile.js";
+export * from "./decorators/params/error.js";
+export * from "./decorators/params/next.js";
+export * from "./decorators/params/request.js";
+export * from "./decorators/params/response.js";
+export * from "./decorators/PlatformProvider.js";
+export * from "./domain/AnyToPromiseWithCtx.js";
+export * from "./domain/EndpointMetadata.js";
+export * from "./domain/PlatformContext.js";
+export * from "./domain/PlatformRouteDetails.js";
+export * from "./exports.js";
+export * from "./fn/adapter.js";
+export * from "./fn/application.js";
+export * from "./interfaces/AfterInit.js";
+export * from "./interfaces/AfterListen.js";
+export * from "./interfaces/AfterRoutesInit.js";
+export * from "./interfaces/BeforeInit.js";
+export * from "./interfaces/BeforeListen.js";
+export * from "./interfaces/BeforeRoutesInit.js";
+export * from "./interfaces/HandlerType.js";
+export * from "./interfaces/IncomingEvent.js";
+export * from "./interfaces/OnReady.js";
+export * from "./interfaces/OnRequest.js";
+export * from "./interfaces/OnResponse.js";
+export * from "./interfaces/OnRoutesInit.js";
+export * from "./interfaces/PlatformRouteOptions.js";
+export * from "./interfaces/ResponseErrorObject.js";
+export * from "./interfaces/Route.js";
+export * from "./middlewares/PlatformAcceptMimesMiddleware.js";
+export * from "./middlewares/PlatformMulterMiddleware.js";
+export * from "./services/Platform.js";
+export * from "./services/PlatformAdapter.js";
+export * from "./services/PlatformApplication.js";
+export * from "./services/PlatformHandler.js";
+export * from "./services/PlatformMiddlewaresChain.js";
+export * from "./services/PlatformRequest.js";
+export * from "./services/PlatformResponse.js";
+export * from "./utils/closeServer.js";
+export * from "./utils/createContext.js";
+export * from "./utils/createHttpServer.js";
+export * from "./utils/createHttpsServer.js";
+export * from "./utils/createInjector.js";
+export * from "./utils/createServer.js";
+export * from "./utils/ensureContext.js";
+export * from "./utils/getStaticsOptions.js";
+export * from "./utils/listenServer.js";
+export * from "./utils/mapReturnedResponse.js";
+export * from "./utils/printRoutes.js";
+export * from "./utils/resolveControllers.js";
+export * from "./utils/setResponseHeaders.js";

package/src/common/interfaces/AfterInit.ts

@@ -0,0 +1,3 @@
+export interface AfterInit {
+  $afterInit(): void | Promise<any>;
+}

package/src/common/interfaces/AfterListen.ts

@@ -0,0 +1,3 @@
+export interface AfterListen {
+  $afterListen(): void | Promise<any>;
+}

package/src/common/interfaces/AfterRoutesInit.ts

@@ -0,0 +1,3 @@
+export interface AfterRoutesInit {
+  $afterRoutesInit(): void | Promise<any>;
+}

package/src/common/interfaces/BeforeInit.ts

@@ -0,0 +1,3 @@
+export interface BeforeInit {
+  $beforeInit(): void | Promise<any>;
+}

package/src/common/interfaces/BeforeListen.ts

@@ -0,0 +1,3 @@
+export interface BeforeListen {
+  $beforeListen(): void | Promise<any>;
+}

package/src/common/interfaces/BeforeRoutesInit.ts

@@ -0,0 +1,3 @@
+export interface BeforeRoutesInit {
+  $beforeRoutesInit(): void | Promise<any>;
+}

package/src/common/interfaces/HandlerType.ts

@@ -0,0 +1,12 @@
+/**
+ * @ignore
+ */
+export enum HandlerType {
+  CUSTOM = "custom",
+  ENDPOINT = "endpoint",
+  MIDDLEWARE = "middleware",
+  ERR_MIDDLEWARE = "err:middleware",
+  CTX_FN = "context",
+  RAW_FN = "raw:middleware",
+  RAW_ERR_FN = "raw:err:middleware"
+}

package/src/common/interfaces/IncomingEvent.ts

@@ -0,0 +1,6 @@
+import {IncomingMessage, ServerResponse} from "http";
+
+export interface IncomingEvent<Req = IncomingMessage, Res = ServerResponse> extends Record<string, unknown> {
+  response: Res;
+  request: Req;
+}

package/src/common/interfaces/OnReady.ts

@@ -0,0 +1,3 @@
+export interface OnReady {
+  $onReady(): void | Promise<any>;
+}

package/src/common/interfaces/OnRequest.ts

@@ -0,0 +1,5 @@
+import {PlatformContext} from "../domain/PlatformContext.js";
+
+export interface OnRequest {
+  $onRequest(ctx: PlatformContext): void;
+}

package/src/common/interfaces/OnResponse.ts

@@ -0,0 +1,5 @@
+import {PlatformResponse} from "../services/PlatformResponse.js";
+
+export interface OnResponse {
+  $onResponse(ctx: PlatformResponse): void;
+}

package/src/common/interfaces/OnRoutesInit.ts

@@ -0,0 +1,3 @@
+export interface OnRoutesInit {
+  $onRoutesInit(): void | Promise<any>;
+}

package/src/common/interfaces/PlatformRouteOptions.ts

@@ -0,0 +1,17 @@
+import {Type} from "@tsed/core";
+import {PathType} from "@tsed/di";
+
+/**
+ * @ignore
+ */
+export interface PlatformRouteOptions {
+  token?: Type<any>;
+  path?: PathType | undefined;
+  method?: string;
+  handlers: any[];
+}
+
+/**
+ * @ignore
+ */
+export type PlatformRouteWithoutHandlers = Partial<Omit<PlatformRouteOptions, "handlers">>;

package/src/common/interfaces/ResponseErrorObject.ts

@@ -0,0 +1,8 @@
+/**
+ * Interface can be implemented to customize the error sent to the client.
+ */
+export interface ResponseErrorObject extends Error {
+  errors?: Error[] | Error | any;
+  origin?: Error;
+  headers?: {};
+}

package/src/common/interfaces/Route.ts

@@ -0,0 +1,12 @@
+import {Provider, TokenProvider} from "@tsed/di";
+
+export interface Route extends Record<string, any> {
+  route: string;
+  token: TokenProvider;
+}
+
+export interface RouteController {
+  route: string;
+  routes: Set<string>;
+  provider: Provider;
+}