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

package/src/common/utils/createHttpsServer.spec.ts

@@ -1,74 +0,0 @@
-import Https from "node:https";
-
-import {configuration, destroyInjector, injector, InjectorService} from "@tsed/di";
-
-import {createHttpsServer} from "./createHttpsServer.js";
-
-describe("createHttpsServer", () => {
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-  afterEach(() => destroyInjector());
-  it("should create an instance of Https (Https port true)", async () => {
-    configuration().set("httpsPort", true);
-
-    const fn: any = vi.fn();
-
-    const listener = createHttpsServer(fn)!;
-
-    expect(!!injector().get(Https.Server)).toEqual(true);
-    expect(listener).toBeInstanceOf(Function);
-
-    const server = injector().get(Https.Server)!;
-
-    vi.spyOn(injector().logger, "info").mockReturnValue(undefined);
-    vi.spyOn(injector().logger, "debug").mockReturnValue(undefined);
-    vi.spyOn(server, "listen").mockReturnValue(undefined as never);
-    vi.spyOn(server, "address").mockReturnValue({port: 8089, address: "0.0.0.0"} as never);
-    vi.spyOn(server, "on").mockImplementation(((event: string, cb: any) => {
-      if (event === "listening") {
-        cb();
-      }
-    }) as never);
-
-    await listener();
-
-    expect(server.listen).toHaveBeenCalledWith(true, "0.0.0.0");
-    expect(injector().logger.info).toHaveBeenCalledWith("Listen server on https://0.0.0.0:8089");
-  });
-
-  it("should create a raw object (Https port false)", () => {
-    configuration().set("httpsPort", false);
-
-    const fn: any = vi.fn();
-
-    const listener = createHttpsServer(fn);
-
-    expect(injector().get(Https.Server)).toEqual(null);
-
-    expect(listener).toBeUndefined();
-  });
-
-  it("should create an instance of Https (https port 0)", () => {
-    configuration().set("httpsPort", 0);
-
-    const fn: any = vi.fn();
-
-    const listener = createHttpsServer(fn);
-
-    expect(!!injector().get(Https.Server)).toEqual(true);
-
-    expect(listener).toBeInstanceOf(Function);
-  });
-  it("should create an instance of Https (https port + address)", () => {
-    configuration().set("httpsPort", "0.0.0.0:8080");
-
-    const fn: any = vi.fn();
-
-    const listener = createHttpsServer(fn);
-
-    expect(!!injector().get(Https.Server)).toEqual(true);
-
-    expect(listener).toBeInstanceOf(Function);
-  });
-});

package/src/common/utils/createHttpsServer.ts

@@ -1,17 +0,0 @@
-import Http from "node:http";
-import Https from "node:https";
-
-import {configuration, constant, InjectorService} from "@tsed/di";
-
-import {createServer} from "./createServer.js";
-
-export function createHttpsServer(requestListener?: Http.RequestListener) {
-  const httpsOptions = configuration().get("httpsOptions");
-
-  return createServer({
-    type: "https",
-    token: Https.Server,
-    port: constant("httpsPort"),
-    server: () => Https.createServer(httpsOptions, requestListener)
-  });
-}

package/src/common/utils/createInjector.spec.ts

@@ -1,42 +0,0 @@
-import {Env} from "@tsed/core";
-import {$log} from "@tsed/logger";
-
-import {FakeAdapter} from "../../testing/FakeAdapter.js";
-import {PlatformConfiguration} from "../config/services/PlatformConfiguration.js";
-import {PlatformAdapter} from "../services/PlatformAdapter.js";
-import {createInjector} from "./createInjector.js";
-
-describe("createInjector", () => {
-  beforeEach(() => {
-    vi.spyOn($log, "stop").mockReturnValue(undefined as any);
-  });
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-  it("should create injector and stop logger in env Test", () => {
-    const settings = {
-      test: "test",
-      env: Env.TEST,
-      adapter: FakeAdapter
-    };
-
-    const injector = createInjector(settings);
-
-    expect(injector.settings).toBeInstanceOf(PlatformConfiguration);
-    expect(injector.settings.get("test")).toEqual("test");
-    expect(injector.logger).toEqual($log);
-    expect(injector.get(PlatformAdapter)).toBeInstanceOf(FakeAdapter);
-  });
-
-  it("should create injector", () => {
-    const settings = {
-      test: "test",
-      env: Env.PROD,
-      adapter: FakeAdapter
-    };
-
-    const injector = createInjector(settings);
-
-    expect(injector.logger.stop).not.toHaveBeenCalled();
-  });
-});

package/src/common/utils/createInjector.ts

@@ -1,25 +0,0 @@
-import {injector, setLoggerConfiguration} from "@tsed/di";
-import {$log} from "@tsed/logger";
-
-import {PlatformConfiguration} from "../config/services/PlatformConfiguration.js";
-import {adapter as $adapter} from "../fn/adapter.js";
-import {PlatformAdapter} from "../services/PlatformAdapter.js";
-
-$log.name = "TSED";
-
-export function createInjector(settings: Partial<TsED.Configuration>) {
-  const inj = injector();
-  inj.addProvider(PlatformConfiguration);
-
-  inj.settings = inj.invoke(PlatformConfiguration);
-  inj.logger = $log;
-  inj.settings.set(settings);
-
-  setLoggerConfiguration();
-
-  $adapter(settings.adapter);
-
-  inj.invoke(PlatformAdapter);
-
-  return inj;
-}

package/src/common/utils/createServer.ts

@@ -1,52 +0,0 @@
-import Http from "node:http";
-import Https from "node:https";
-
-import {getHostInfoFromPort, ReturnHostInfoFromPort} from "@tsed/core";
-import {configuration, injector, logger, ProviderScope, TokenProvider} from "@tsed/di";
-import Http2 from "http2";
-
-import {listenServer} from "./listenServer.js";
-
-export interface CreateServerOptions {
-  token: TokenProvider;
-  type: "http" | "https";
-  port: string | false | undefined;
-  listen?: (hostInfo: ReturnHostInfoFromPort) => Promise<any>;
-  server: () => Http.Server | Https.Server | Http2.Http2Server;
-}
-
-export type CreateServerReturn = () => Promise<Http.Server | Https.Server | Http2.Http2Server>;
-
-export function createServer({token, type, port, server: get, listen}: CreateServerOptions): undefined | CreateServerReturn {
-  const server = port !== false ? get() : null;
-
-  injector().addProvider(token, {
-    scope: ProviderScope.SINGLETON,
-    useValue: server
-  });
-
-  injector().invoke(token);
-
-  if (server) {
-    const hostInfo = getHostInfoFromPort(type, port);
-
-    return async () => {
-      const url = `${hostInfo.protocol}://${hostInfo.address}:${port}`;
-      logger().debug(`Start server on ${url}`);
-
-      await (listen ? listen(hostInfo) : listenServer(server, hostInfo));
-
-      const address = server.address();
-
-      if (address && typeof address !== "string") {
-        hostInfo.address = address.address;
-        hostInfo.port = address.port;
-      }
-
-      logger().info(`Listen server on ${hostInfo.toString()}`);
-      configuration().set(`${type}Port`, `${hostInfo.address}:${hostInfo.port}`);
-
-      return server;
-    };
-  }
-}

package/src/common/utils/ensureContext.spec.ts

@@ -1,41 +0,0 @@
-import {runInContext} from "@tsed/di";
-
-import {PlatformTest} from "../../testing/PlatformTest.js";
-import {ensureContext} from "./ensureContext.js";
-
-describe("ensureContext()", () => {
-  beforeEach(() => PlatformTest.create());
-  afterEach(() => PlatformTest.reset());
-
-  it("should return context (no async_hook)", async () => {
-    const $ctx = PlatformTest.createRequestContext();
-    const stub = vi.fn();
-    const req = {
-      $ctx
-    };
-
-    await ensureContext(req, stub);
-
-    expect(stub).toHaveBeenCalledWith($ctx);
-  });
-
-  it("should return context (with async_hook)", async () => {
-    const $ctx = PlatformTest.createRequestContext();
-    const stub = vi.fn();
-    const req = {};
-
-    await runInContext($ctx, () => ensureContext(req, stub));
-
-    expect(stub).toHaveBeenCalledWith($ctx);
-  });
-
-  it("should return context (no async_hook, no context)", async () => {
-    const stub = vi.fn();
-    const fallback = vi.fn();
-    const req = {};
-
-    await ensureContext(req, stub, fallback);
-
-    expect(fallback).toHaveBeenCalledWith();
-  });
-});

package/src/common/utils/ensureContext.ts

@@ -1,17 +0,0 @@
-import {getContext, runInContext} from "@tsed/di";
-
-import {PlatformContext} from "../domain/PlatformContext.js";
-
-export function ensureContext(request: any, cb: ($ctx: PlatformContext) => any, fallback?: () => void) {
-  const $ctx = getContext<PlatformContext>();
-
-  if ($ctx) {
-    return cb($ctx);
-  }
-
-  if (!request?.$ctx && fallback) {
-    return fallback();
-  }
-
-  return runInContext(request.$ctx, () => cb(request.$ctx));
-}

package/src/common/utils/getConfiguration.spec.ts

@@ -1,163 +0,0 @@
-import {Env} from "@tsed/core";
-import {Configuration} from "@tsed/di";
-
-import {getConfiguration} from "./getConfiguration.js";
-
-class MyCtrl {}
-
-describe("getConfiguration()", () => {
-  it("should return configuration (2)", () => {
-    @Configuration({
-      mount: {
-        "/v1": [MyCtrl]
-      }
-    })
-    class MyModule {}
-
-    expect(
-      getConfiguration(
-        {
-          mount: {
-            "/v2": [MyCtrl]
-          }
-        },
-        MyModule
-      )
-    ).toEqual({
-      $$resolved: true,
-      env: "test",
-      httpPort: 8080,
-      httpsPort: false,
-      logger: {
-        debug: false,
-        jsonIndentation: 2,
-        level: "off",
-        logRequest: true
-      },
-      mount: {
-        "/v1": [MyCtrl],
-        "/v2": [MyCtrl]
-      },
-      scopes: {
-        controller: "singleton"
-      }
-    });
-  });
-  it("should load configuration for test", () => {
-    @Configuration({})
-    class App {}
-
-    const config = getConfiguration({}, App);
-
-    expect(config).toEqual({
-      $$resolved: true,
-      env: "test",
-      httpPort: 8080,
-      httpsPort: false,
-      logger: {
-        debug: false,
-        jsonIndentation: 2,
-        level: "off",
-        logRequest: true
-      },
-      mount: {},
-      scopes: {
-        controller: "singleton"
-      }
-    });
-  });
-  it("should load configuration for production", () => {
-    @Configuration({
-      env: Env.PROD
-    })
-    class App {}
-
-    const config = getConfiguration({}, App);
-
-    expect(config).toEqual({
-      $$resolved: true,
-      env: Env.PROD,
-      httpPort: 8080,
-      httpsPort: false,
-      logger: {
-        debug: false,
-        jsonIndentation: 2,
-        level: "info",
-        logRequest: true
-      },
-      mount: {},
-      scopes: {
-        controller: "singleton"
-      }
-    });
-  });
-  it("should load configuration with mount from config", () => {
-    @Configuration({
-      env: Env.PROD
-    })
-    class App {}
-
-    class Ctrl {}
-
-    const config = getConfiguration(
-      {
-        mount: {
-          "/": [Ctrl]
-        }
-      },
-      App
-    );
-
-    expect(config).toEqual({
-      $$resolved: true,
-      env: Env.PROD,
-      httpPort: 8080,
-      httpsPort: false,
-      logger: {
-        debug: false,
-        jsonIndentation: 2,
-        level: "info",
-        logRequest: true
-      },
-      mount: {
-        "/": [Ctrl]
-      },
-      scopes: {
-        controller: "singleton"
-      }
-    });
-  });
-  it("should load configuration with mount from decorator", () => {
-    class Ctrl {}
-
-    @Configuration({
-      env: Env.PROD,
-      mount: {
-        "/": [Ctrl]
-      }
-    })
-    class App {}
-
-    let config = getConfiguration({}, App);
-    config = getConfiguration(config, App);
-
-    expect(config).toEqual({
-      $$resolved: true,
-      env: Env.PROD,
-      httpPort: 8080,
-      httpsPort: false,
-      logger: {
-        debug: false,
-        jsonIndentation: 2,
-        level: "info",
-        logRequest: true
-      },
-      mount: {
-        "/": [Ctrl]
-      },
-      scopes: {
-        controller: "singleton"
-      }
-    });
-  });
-});

package/src/common/utils/getConfiguration.ts

@@ -1,34 +0,0 @@
-import {Env, Store, Type} from "@tsed/core";
-import {mergeMount, ProviderScope, ProviderType} from "@tsed/di";
-
-export function getConfiguration(configuration: any = {}, module: Type<any> | null = null) {
-  if (configuration.$$resolved) {
-    return configuration;
-  }
-
-  const store = module ? Store.from(module).get("configuration") || {} : {};
-  const env = configuration.env || store.env || (process.env.NODE_ENV as Env) || Env.DEV;
-
-  return {
-    $$resolved: true,
-    env,
-    httpPort: 8080,
-    httpsPort: false,
-    ...store,
-    ...configuration,
-    scopes: {
-      [ProviderType.CONTROLLER]: ProviderScope.SINGLETON,
-      ...store.scopes,
-      ...configuration.scopes
-    },
-    mount: mergeMount(store.mount, configuration.mount),
-    logger: {
-      debug: false,
-      level: env === Env.TEST ? "off" : "info",
-      logRequest: true,
-      ...store.logger,
-      ...configuration.logger,
-      jsonIndentation: process.env.NODE_ENV === Env.PROD ? 0 : 2
-    }
-  };
-}

package/src/common/utils/getStaticsOptions.spec.ts

@@ -1,27 +0,0 @@
-import {getStaticsOptions} from "./getStaticsOptions.js";
-
-describe("getStaticsOptions()", () => {
-  it("should return the statics files options", () => {
-    const result = getStaticsOptions({
-      "/": ["/root", {root: "/root2", test: "test", hook: "$beforeRoutesInit"}]
-    });
-
-    expect(result).toEqual([
-      {
-        options: {
-          hook: "$afterRoutesInit",
-          root: "/root"
-        },
-        path: "/"
-      },
-      {
-        options: {
-          hook: "$beforeRoutesInit",
-          root: "/root2",
-          test: "test"
-        },
-        path: "/"
-      }
-    ]);
-  });
-});

package/src/common/utils/getStaticsOptions.ts

@@ -1,24 +0,0 @@
-import {getValue} from "@tsed/core";
-
-import {PlatformStaticsOptions, PlatformStaticsSettings} from "../config/interfaces/PlatformStaticsSettings.js";
-
-function mapOptions(options: any): any {
-  const opts: PlatformStaticsOptions = typeof options === "string" ? {root: options} : options;
-  return {
-    ...opts,
-    hook: getValue(opts, "hook", "$afterRoutesInit")
-  };
-}
-
-export function getStaticsOptions(statics?: PlatformStaticsSettings): {path: string; options: PlatformStaticsOptions}[] {
-  return Object.entries(statics || {}).reduce(
-    (statics, [path, items]) => {
-      [].concat(items as any).forEach((options) => {
-        statics.push({path, options: mapOptions(options)});
-      });
-
-      return statics;
-    },
-    [] as {path: string; options: PlatformStaticsOptions}[]
-  );
-}

package/src/common/utils/listenServer.ts

@@ -1,18 +0,0 @@
-import type Http from "node:http";
-import type Https from "node:https";
-
-import {getHostInfoFromPort} from "@tsed/core";
-import type Http2 from "http2";
-
-export function listenServer(server: Http.Server | Https.Server | Http2.Http2Server, hostInfo: ReturnType<typeof getHostInfoFromPort>) {
-  const {address, port} = hostInfo;
-
-  const promise = new Promise((resolve, reject) => {
-    server.on("listening", resolve);
-    server.on("error", reject);
-  });
-
-  server.listen(port, address as any);
-
-  return promise;
-}

package/src/common/utils/mapReturnedResponse.spec.ts

@@ -1,35 +0,0 @@
-import {mapReturnedResponse} from "../index.js";
-
-describe("mapReturnedResponse", () => {
-  it("should map the response (1)", () => {
-    expect(
-      mapReturnedResponse({
-        description: "description",
-        type: "type",
-        collection: "collection",
-        headers: "headers"
-      })
-    ).toEqual({
-      description: "description",
-      type: "type",
-      collectionType: "collection",
-      headers: "headers"
-    });
-  });
-
-  it("should map the response (2)", () => {
-    expect(
-      mapReturnedResponse({
-        description: "description",
-        use: "use",
-        collection: "collection",
-        headers: "headers"
-      })
-    ).toEqual({
-      description: "description",
-      type: "use",
-      collectionType: "collection",
-      headers: "headers"
-    });
-  });
-});

package/src/common/utils/mapReturnedResponse.ts

@@ -1,10 +0,0 @@
-/**
- * @ignore
- */
-export function mapReturnedResponse({use, collection, ...options}: any): any {
-  return {
-    ...options,
-    type: options.type || use,
-    collectionType: options.collectionType || collection
-  };
-}

package/src/common/utils/printRoutes.spec.ts

@@ -1,19 +0,0 @@
-import {printRoutes} from "./printRoutes.js";
-
-describe("printRoutes()", () => {
-  it("should return routes", () => {
-    const routes = [
-      {
-        method: "GET",
-        url: "/",
-        name: "name",
-        toJSON() {
-          return this;
-        }
-      }
-    ];
-
-    // tslint:disable-next-line: no-unused-variable
-    expect(typeof printRoutes(routes as any)).toBe("string");
-  });
-});

package/src/common/utils/printRoutes.ts

@@ -1,40 +0,0 @@
-import {$log, colorize} from "@tsed/logger";
-
-import {PlatformRouteDetails} from "../domain/PlatformRouteDetails.js";
-
-export function printRoutes(routes: PlatformRouteDetails[]) {
-  const mapColor: {[key: string]: string} = {
-    GET: "green",
-    POST: "yellow",
-    PUT: "blue",
-    DELETE: "red",
-    PATCH: "magenta",
-    ALL: "cyan",
-    STATICS: "white"
-  };
-
-  const list = routes.map((route) => {
-    const method = route.method.toUpperCase();
-
-    return {
-      ...route,
-      method: {
-        length: method.length,
-        toString: () => {
-          return colorize(method, mapColor[method]);
-        }
-      }
-    };
-  });
-
-  const str = $log.drawTable(list, {
-    padding: 1,
-    header: {
-      method: "Method",
-      url: "Endpoint",
-      name: "Class method"
-    }
-  });
-
-  return "\n" + str.trim();
-}

package/src/common/utils/resolveControllers.spec.ts

@@ -1,40 +0,0 @@
-import {nameOf} from "@tsed/core";
-
-import {Controller} from "../../../../../di/src/common/decorators/controller.js";
-import {M1Ctrl1} from "../../../../../di/src/common/utils/__mock__/module1/controllers/M1Ctrl1.js";
-import {Module1} from "../../../../../di/src/common/utils/__mock__/module1/Module1.js";
-import {M2Ctrl} from "../../../../../di/src/common/utils/__mock__/module2/controllers/M2Ctrl.js";
-import {Module2} from "../../../../../di/src/common/utils/__mock__/module2/Module2.js";
-import {resolveControllers} from "./resolveControllers.js";
-
-@Controller("/root")
-class TestCtrl {}
-
-describe("resolveControllers", () => {
-  it("should load providers and merge configuration", () => {
-    const configuration = {
-      mount: {
-        "/rest": [TestCtrl]
-      },
-      imports: [Module1, Module2]
-    };
-
-    const result = resolveControllers(configuration);
-    const routes = result.map((item) => ({...item, token: nameOf(item.token)}));
-
-    expect(routes).toEqual([
-      {
-        route: "/m1",
-        token: "M1Ctrl1"
-      },
-      {
-        route: "/mod2",
-        token: "M2Ctrl"
-      },
-      {
-        route: "/rest",
-        token: "TestCtrl"
-      }
-    ]);
-  });
-});