@tsed/platform-http 8.11.1 → 8.11.2-rc.1

package/src/common/services/PlatformApplication.spec.ts

@@ -1,89 +0,0 @@
-import {configuration} from "@tsed/di";
-
-import {PlatformTest} from "../../testing/PlatformTest.js";
-import {createContext} from "../utils/createContext.js";
-import {PlatformApplication} from "./PlatformApplication.js";
-import {PlatformHandler} from "./PlatformHandler.js";
-
-vi.mock("../utils/createContext");
-
-function createDriver() {
-  return {
-    use: vi.fn(),
-    all: vi.fn(),
-    get: vi.fn(),
-    post: vi.fn(),
-    put: vi.fn(),
-    delete: vi.fn(),
-    patch: vi.fn(),
-    head: vi.fn(),
-    options: vi.fn()
-  };
-}
-
-async function getPlatformApp() {
-  const platformHandler = {
-    createHandler: vi.fn().mockImplementation((o) => o)
-  };
-  const platformApp = await PlatformTest.invoke<PlatformApplication<any>>(PlatformApplication, [
-    {
-      token: PlatformHandler,
-      use: platformHandler
-    }
-  ]);
-  configuration().logger = {};
-  platformApp.rawApp = createDriver() as any;
-
-  return {platformApp, platformHandler};
-}
-
-describe("PlatformApplication", () => {
-  beforeEach(PlatformTest.create);
-  afterEach(PlatformTest.reset);
-
-  describe("getApp()", () => {
-    it("should return app", async () => {
-      // GIVEN
-      const {platformApp} = await getPlatformApp();
-
-      // WHEN
-      expect(platformApp.getApp()).toEqual(platformApp.rawApp);
-    });
-  });
-
-  describe("statics()", () => {
-    it("should call statics", async () => {
-      // GIVEN
-      const {platformApp} = await getPlatformApp();
-
-      vi.spyOn(console, "warn");
-
-      // WHEN
-      platformApp.statics("/", {root: "/root"});
-    });
-  });
-
-  describe("callback()", () => {
-    it("should return the callback", async () => {
-      const $ctx = {
-        runInContext: vi.fn().mockImplementation((cb) => {
-          cb();
-        })
-      };
-
-      const {platformApp} = await getPlatformApp();
-
-      (createContext as any).mockReturnValue(() => Promise.resolve($ctx));
-
-      // WHEN
-      const callback = vi.fn();
-
-      vi.spyOn(platformApp, "rawCallback").mockReturnValue(callback);
-
-      await platformApp.callback({} as any, {} as any);
-
-      expect(platformApp.rawCallback).toHaveBeenCalledWith();
-      expect(callback).toHaveBeenCalledWith({}, {});
-    });
-  });
-});

package/src/common/services/PlatformApplication.ts

@@ -1,38 +0,0 @@
-import {IncomingMessage, ServerResponse} from "node:http";
-
-import {injectable, ProviderScope} from "@tsed/di";
-import {PlatformRouter} from "@tsed/platform-router";
-
-declare global {
-  namespace TsED {
-    // @ts-ignore
-    export interface Application {}
-  }
-}
-
-/**
- * `PlatformApplication` is used to provide all routes collected by annotation `@Controller`.
- *
- * @platform
- */
-export class PlatformApplication<App = TsED.Application> extends PlatformRouter {
-  rawApp: App;
-
-  rawCallback(): any {}
-
-  getApp(): App {
-    return this.rawApp;
-  }
-
-  callback(): (req: IncomingMessage, res: ServerResponse) => any;
-  callback(req: IncomingMessage, res: ServerResponse): any;
-  callback(req?: IncomingMessage, res?: ServerResponse) {
-    if (req && res) {
-      return this.callback()(req, res);
-    }
-
-    return this.rawCallback();
-  }
-}
-
-injectable(PlatformApplication).scope(ProviderScope.SINGLETON).alias("PlatformApplication");

package/src/common/services/PlatformHandler.spec.ts

@@ -1,152 +0,0 @@
-import {Injectable, runInContext} from "@tsed/di";
-import {PlatformHandlerMetadata, PlatformHandlerType} from "@tsed/platform-router";
-import {EndpointMetadata, Get, View} from "@tsed/schema";
-
-import {PlatformTest} from "../../testing/PlatformTest.js";
-import {PlatformHandler} from "./PlatformHandler.js";
-
-function getServiceFixture() {
-  const service = PlatformTest.get<PlatformHandler>(PlatformHandler);
-  return {service};
-}
-
-describe("PlatformHandler", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(() => PlatformTest.create());
-
-  describe("createHandler()", () => {
-    it("should create handler", async () => {
-      const {service} = getServiceFixture();
-      const handler = vi.fn();
-      const metadata = new PlatformHandlerMetadata({
-        handler,
-        type: PlatformHandlerType.CTX_FN
-      });
-
-      const $ctx = PlatformTest.createRequestContext();
-
-      const result = service.createHandler(metadata);
-
-      expect(typeof result).toEqual("function");
-
-      await result($ctx);
-
-      expect(handler).toHaveBeenCalledWith($ctx);
-    });
-    it("should create handler from provider", async () => {
-      const {service} = getServiceFixture();
-
-      @Injectable()
-      class Test {
-        @Get("/")
-        get() {
-          return "test";
-        }
-      }
-
-      PlatformTest.injector.addProvider(Test);
-
-      const metadata = new PlatformHandlerMetadata({
-        provider: PlatformTest.injector.getProvider(Test),
-        propertyKey: "get",
-        type: PlatformHandlerType.ENDPOINT
-      });
-
-      const $ctx = PlatformTest.createRequestContext();
-      $ctx.endpoint = EndpointMetadata.get(Test, "get");
-
-      const result = service.createHandler(metadata);
-
-      expect(typeof result).toEqual("function");
-
-      await result($ctx);
-
-      expect($ctx.data).toEqual("test");
-    });
-  });
-  describe("createCustomHandler()", () => {
-    it("should create handler", async () => {
-      @Injectable()
-      class TestService {
-        @View("test")
-        use() {
-          return Promise.resolve("hello");
-        }
-      }
-
-      const {service} = getServiceFixture();
-
-      const $ctx = PlatformTest.createRequestContext();
-      const testService = await PlatformTest.invoke<TestService>(TestService)!;
-      const provider = PlatformTest.injector.getProvider(TestService)!;
-
-      vi.spyOn(testService, "use").mockResolvedValue("hello");
-
-      const result = service.createCustomHandler(provider, "use");
-
-      expect(result).toBeInstanceOf(Function);
-
-      await runInContext($ctx, () => result($ctx));
-
-      expect($ctx.data).toEqual("hello");
-      expect(testService.use).toHaveBeenCalledWith($ctx);
-    });
-  });
-  describe("onRequest()", () => {
-    it("should do nothing when the request is done", async () => {
-      const {service} = getServiceFixture();
-      const handler = vi.fn();
-
-      const $ctx = PlatformTest.createRequestContext();
-      $ctx.next = vi.fn();
-
-      await $ctx.finish();
-
-      $ctx.handlerMetadata = new PlatformHandlerMetadata({
-        handler
-      });
-
-      await service.onRequest(handler, $ctx);
-
-      expect(handler).not.toHaveBeenCalled();
-    });
-    it("should apply headers and status", async () => {
-      @Injectable()
-      class TestService {
-        @Get("/")
-        use() {
-          return Promise.resolve("hello");
-        }
-      }
-
-      const {service} = getServiceFixture();
-      const handler = vi.fn().mockResolvedValue({
-        status: 201,
-        statusText: "CREATED",
-        headers: {
-          test: "test"
-        },
-        data: "data"
-      });
-
-      const $ctx = PlatformTest.createRequestContext();
-      $ctx.next = vi.fn();
-      $ctx.endpoint = EndpointMetadata.get(TestService, "use");
-
-      $ctx.handlerMetadata = new PlatformHandlerMetadata({
-        handler: TestService.prototype.use
-      });
-
-      vi.spyOn(service, "flush").mockResolvedValue();
-
-      await service.onRequest(handler, $ctx);
-
-      expect(handler).toHaveBeenCalled();
-      expect($ctx.response.statusCode).toEqual(201);
-      expect($ctx.response.getHeaders()).toEqual({
-        test: "test",
-        "x-request-id": "id"
-      });
-    });
-  });
-});

package/src/common/services/PlatformHandler.ts

@@ -1,137 +0,0 @@
-import {AnyPromiseResult, AnyToPromiseStatus, catchAsyncError} from "@tsed/core";
-import {inject, injectable, Provider, ProviderScope} from "@tsed/di";
-import {$alter} from "@tsed/hooks";
-import {PlatformExceptions} from "@tsed/platform-exceptions";
-import {PlatformParams, PlatformParamsCallback} from "@tsed/platform-params";
-import {PlatformResponseFilter} from "@tsed/platform-response-filter";
-import {
-  AlterEndpointHandlersArg,
-  PlatformHandlerMetadata,
-  PlatformHandlerType,
-  PlatformRouters,
-  useResponseHandler
-} from "@tsed/platform-router";
-import {JsonOperationRoute} from "@tsed/schema";
-
-import {AnyToPromiseWithCtx} from "../domain/AnyToPromiseWithCtx.js";
-import {PlatformContext} from "../domain/PlatformContext.js";
-import {setResponseHeaders} from "../utils/setResponseHeaders.js";
-import {PlatformAdapter} from "./PlatformAdapter.js";
-
-/**
- * Platform Handler abstraction layer. Wrap original class method to a pure platform handler (Express, Koa, etc...).
- * @platform
- */
-export class PlatformHandler {
-  protected responseFilter = inject(PlatformResponseFilter);
-  protected platformParams = inject(PlatformParams);
-  protected platformExceptions = inject(PlatformExceptions);
-  protected platformRouters = inject(PlatformRouters);
-
-  constructor() {
-    // configure the router module
-    this.platformRouters.hooks
-      .on("alterEndpointHandlers", (handlers: AlterEndpointHandlersArg, operationRoute: JsonOperationRoute) => {
-        handlers = $alter("$alterEndpointHandlers", handlers, [operationRoute]);
-
-        handlers.after.push(useResponseHandler(this.flush.bind(this)));
-
-        return handlers;
-      })
-      .on("alterHandler", (handlerMetadata: PlatformHandlerMetadata) => {
-        const handler = handlerMetadata.isInjectable() ? this.createHandler(handlerMetadata) : handlerMetadata.handler;
-        handlerMetadata.compiledHandler = handler;
-        return inject(PlatformAdapter).mapHandler(handler, handlerMetadata);
-      });
-  }
-
-  createHandler(handlerMetadata: PlatformHandlerMetadata): any {
-    const handler = this.platformParams.compileHandler(handlerMetadata);
-
-    return ($ctx: PlatformContext) => {
-      $ctx.handlerMetadata = handlerMetadata;
-
-      return this.onRequest(handler, $ctx);
-    };
-  }
-
-  /**
-   * @param provider
-   * @param propertyKey
-   */
-  createCustomHandler(provider: Provider, propertyKey: string) {
-    const metadata = new PlatformHandlerMetadata({
-      provider,
-      type: PlatformHandlerType.CUSTOM,
-      propertyKey
-    });
-
-    return this.createHandler(metadata);
-  }
-
-  /**
-   * Call handler when a request his handle
-   */
-  async onRequest(handler: PlatformParamsCallback, $ctx: PlatformContext) {
-    const {handlerMetadata} = $ctx;
-
-    if (handlerMetadata.type === PlatformHandlerType.CTX_FN) {
-      return handler({$ctx});
-    }
-
-    const resolver = new AnyToPromiseWithCtx($ctx);
-
-    const response = await resolver.call(handler);
-    // Note: restore previous handler metadata (for OIDC)
-    $ctx.handlerMetadata = handlerMetadata;
-
-    if (response.state === AnyToPromiseStatus.RESOLVED && !$ctx.isDone()) {
-      return this.onResponse(response, $ctx);
-    }
-  }
-
-  onResponse({status, data, headers}: AnyPromiseResult, $ctx: PlatformContext) {
-    if (status) {
-      $ctx.response.status(status);
-    }
-
-    if (headers) {
-      $ctx.response.setHeaders(headers);
-    }
-
-    if (data !== undefined) {
-      $ctx.data = data;
-    }
-
-    $ctx.error = null;
-
-    // set headers each times that an endpoint is called
-    if ($ctx.handlerMetadata.isEndpoint()) {
-      setResponseHeaders($ctx);
-    }
-  }
-
-  /**
-   * Send the response to the consumer.
-   * @protected
-   * @param $ctx
-   */
-  async flush($ctx: PlatformContext) {
-    if (!$ctx.error) {
-      $ctx.error = await catchAsyncError(async () => {
-        const {response} = $ctx;
-
-        if (!$ctx.isDone()) {
-          const data = await this.responseFilter.transform($ctx.data, $ctx as any);
-          response.body(data);
-        }
-      });
-    }
-
-    if ($ctx.error) {
-      this.platformExceptions.catch($ctx.error, $ctx);
-    }
-  }
-}
-
-injectable(PlatformHandler).scope(ProviderScope.SINGLETON);

package/src/common/services/PlatformRequest.spec.ts

@@ -1,185 +0,0 @@
-import {PlatformHandlerMetadata} from "@tsed/platform-router";
-
-import {FakeAdapter} from "../../testing/index.js";
-import {PlatformTest} from "../../testing/PlatformTest.js";
-import {PlatformAdapter} from "./PlatformAdapter.js";
-import {PlatformRequest} from "./PlatformRequest.js";
-
-function createRequest() {
-  const $ctx = PlatformTest.createRequestContext();
-
-  return {req: $ctx.request.request, request: $ctx.request};
-}
-
-describe("PlatformRequest", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(() => PlatformTest.reset());
-
-  it("should create a PlatformRequest instance", () => {
-    const request = PlatformTest.createRequest();
-    const response = PlatformTest.createResponse();
-    const $ctx = PlatformTest.createRequestContext({
-      event: {
-        request,
-        response
-      }
-    });
-
-    expect($ctx.request.raw).toEqual(request);
-    expect($ctx.request.response).toEqual($ctx.response);
-    expect($ctx.request.headers).toEqual({});
-    expect($ctx.request.get("host")).toEqual(undefined);
-    expect($ctx.request.getHeader("host")).toEqual(undefined);
-    expect($ctx.request.method).toEqual("GET");
-  });
-
-  describe("secure()", () => {
-    it("should return the secure request state (false)", () => {
-      const $ctx = PlatformTest.createRequestContext();
-
-      $ctx.request.request.secure = false;
-
-      expect($ctx.request.secure).toEqual(false);
-    });
-    it("should return the secure request state (true)", () => {
-      const $ctx = PlatformTest.createRequestContext();
-
-      $ctx.request.request.secure = true;
-      expect($ctx.request.secure).toEqual(true);
-    });
-  });
-
-  describe("route()", () => {
-    it("should return route", () => {
-      const $ctx = PlatformTest.createRequestContext();
-      $ctx.handlerMetadata = new PlatformHandlerMetadata({
-        handler: () => {}
-      });
-      $ctx.handlerMetadata.path = "/id";
-
-      expect($ctx.request.route).toEqual("/id");
-    });
-  });
-
-  describe("protocol()", () => {
-    it("should return the protocol request state (http)", () => {
-      const $ctx = PlatformTest.createRequestContext();
-
-      $ctx.request.request.protocol = "http";
-
-      expect($ctx.request.protocol).toEqual("http");
-    });
-    it("should return the protocol request state (https)", () => {
-      const {req, request} = createRequest();
-
-      req.protocol = "https";
-      expect(request.protocol).toEqual("https");
-    });
-  });
-
-  describe("host()", () => {
-    it("should return the host", () => {
-      const {request} = createRequest();
-
-      request.raw.headers["host"] = "host";
-
-      expect(request.host).toEqual("host");
-    });
-  });
-
-  describe("accepts()", () => {
-    it("should set the accepts header", () => {
-      const {req, request} = createRequest();
-
-      vi.spyOn(req, "accepts");
-
-      request.accepts("application/json");
-
-      expect(req.accepts).toHaveBeenCalledWith("application/json");
-    });
-  });
-
-  describe("rawBody()", () => {
-    it("should return the rawBody", () => {
-      const {req, request} = createRequest();
-      req.rawBody = "raw";
-      const raw = request.rawBody;
-
-      expect(raw).toEqual("raw");
-    });
-    it("should return the body", () => {
-      const {req, request} = createRequest();
-      req.body = "raw";
-      const raw = request.rawBody;
-
-      expect(raw).toEqual("raw");
-    });
-  });
-
-  describe("files()", () => {
-    it("should return the files", () => {
-      const {req, request} = createRequest();
-      req.files = "files";
-
-      expect(request.files).toEqual("files");
-    });
-  });
-
-  describe("getReq()", () => {
-    it("should return req", () => {
-      const {req, request} = createRequest();
-
-      expect(request.req).toEqual(req);
-    });
-  });
-
-  describe("getters", () => {
-    it("should return the expected data", () => {
-      const {request} = createRequest();
-      request.raw.originalUrl = "/";
-      request.raw.query =
-        request.raw.session =
-        request.raw.cookies =
-        request.raw.params =
-        request.raw.body =
-          {
-            obj: {
-              test: "testValue"
-            },
-            test: "testValue"
-          };
-
-      expect(request.url).toEqual("/");
-      expect(request.body).toEqual({
-        obj: {
-          test: "testValue"
-        },
-        test: "testValue"
-      });
-      expect(request.params).toEqual({
-        obj: {
-          test: "testValue"
-        },
-        test: "testValue"
-      });
-      expect(request.query).toEqual({
-        obj: {
-          test: "testValue"
-        },
-        test: "testValue"
-      });
-      expect(request.cookies).toEqual({
-        obj: {
-          test: "testValue"
-        },
-        test: "testValue"
-      });
-      expect(request.session).toEqual({
-        obj: {
-          test: "testValue"
-        },
-        test: "testValue"
-      });
-    });
-  });
-});