@tsed/platform-http 8.0.1 → 8.0.3

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

@@ -0,0 +1,73 @@
+import {configuration, destroyInjector, injector, InjectorService} from "@tsed/di";
+import Https from "https";
+
+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

@@ -0,0 +1,16 @@
+import {configuration, constant, InjectorService} from "@tsed/di";
+import Http from "http";
+import Https from "https";
+
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,55 @@
+import {toMap} from "@tsed/core";
+import {injector, ProviderOpts, 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 {Platform} from "../services/Platform.js";
+import {PlatformAdapter} from "../services/PlatformAdapter.js";
+import {PlatformApplication} from "../services/PlatformApplication.js";
+import {PlatformHandler} from "../services/PlatformHandler.js";
+import {PlatformRequest} from "../services/PlatformRequest.js";
+import {PlatformResponse} from "../services/PlatformResponse.js";
+
+$log.name = "TSED";
+
+const DEFAULT_PROVIDERS = [
+  {token: PlatformHandler},
+  {token: PlatformResponse},
+  {token: PlatformRequest},
+  {token: PlatformApplication},
+  {token: Platform}
+];
+
+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();
+
+  const adapterToken = $adapter(settings.adapter);
+
+  inj
+    .addProvider(PlatformAdapter, {
+      useClass: adapterToken
+    })
+    .alias(PlatformAdapter, "PlatformAdapter");
+
+  const adapter = inj.invoke(PlatformAdapter);
+
+  inj.settings.set("PLATFORM_NAME", settings.PLATFORM_NAME || adapter.NAME);
+
+  const instance = inj.get<PlatformAdapter>(PlatformAdapter)!;
+
+  toMap<any, ProviderOpts>(instance.providers, "token").forEach((provider, token) => {
+    inj.addProvider(token, provider);
+  });
+
+  DEFAULT_PROVIDERS.map((provider) => inj.get(provider.token));
+
+  return inj;
+}

package/src/common/utils/createServer.ts

@@ -0,0 +1,51 @@
+import {getHostInfoFromPort, ReturnHostInfoFromPort} from "@tsed/core";
+import {configuration, injector, logger, ProviderScope, TokenProvider} from "@tsed/di";
+import Http from "http";
+import Http2 from "http2";
+import Https from "https";
+
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,17 @@
+import {getHostInfoFromPort} from "@tsed/core";
+import type Http from "http";
+import type Http2 from "http2";
+import type Https from "https";
+
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,10 @@
+/**
+ * @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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,40 @@
+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();
+}