@tsed/platform-http 8.0.1 → 8.0.2

package/src/common/config/services/PlatformConfiguration.spec.ts

@@ -0,0 +1,181 @@
+import {Env} from "@tsed/core";
+import {ProviderScope, ProviderType} from "@tsed/di";
+
+import {PlatformConfiguration} from "./PlatformConfiguration.js";
+
+describe("PlatformConfiguration", () => {
+  let settings: any;
+
+  describe("Test ENV", () => {
+    beforeAll(() => {
+      settings = new PlatformConfiguration();
+
+      Object.entries({
+        rootDir: process.cwd(),
+        env: (process.env.NODE_ENV as Env) || Env.DEV,
+        port: 8080,
+        httpPort: 8080,
+        httpsPort: 8000,
+        version: "1.0.0",
+        scopes: {
+          [ProviderType.CONTROLLER]: ProviderScope.SINGLETON
+        },
+        logger: {
+          debug: false,
+          level: "info",
+          logRequest: true,
+          jsonIndentation: process.env.NODE_ENV === Env.PROD ? 0 : 2
+        },
+        errors: {
+          headerName: "errors"
+        },
+        mount: {},
+        controllerScope: ProviderScope.SINGLETON
+      }).forEach(([key, value]) => {
+        settings[key] = value;
+      });
+
+      settings.env = Env.TEST;
+
+      settings.set("ownConfig", "test");
+      settings.set({ownConfig2: "test"} as any);
+      settings.version = "1.0.0";
+      settings.httpsOptions = {test: "/rest"} as any;
+      settings.acceptMimes = ["application/json"];
+      settings.statics = {"/": "/public"};
+      settings.routers = {mergeParams: true};
+      settings.exclude = ["./**/*.spec.ts"];
+      settings.debug = true;
+      //settings.jsonMapper = {};
+
+      settings.setHttpPort({address: "address", port: 8081});
+      settings.setHttpsPort({address: "address", port: 8080});
+    });
+
+    it("should return rootDir", () => {
+      expect(settings.rootDir).toEqual(process.cwd());
+    });
+
+    it("should return custom keys", () => {
+      expect(settings.get("ownConfig")).toEqual("test");
+    });
+
+    it("should return env", () => {
+      expect(settings.env).toEqual(Env.TEST);
+    });
+
+    it("should have logging jsonIndentaion set to 2", () => {
+      expect(settings.logger.jsonIndentation).toEqual(2);
+    });
+
+    it("should return httpsPort", () => {
+      expect(settings.httpsPort).toEqual("address:8080");
+    });
+
+    it("should return httpPort", () => {
+      expect(settings.httpPort).toEqual("address:8081");
+    });
+
+    it("should return the best host", () => {
+      const info = settings.getHttpsPort();
+      expect(info).toEqual({
+        protocol: "https",
+        address: "address",
+        port: 8080,
+        toString: info.toString
+      });
+      expect(settings.getBestHost().toString()).toEqual("https://address:8080");
+    });
+
+    it("should return httpPort multiple usecase", () => {
+      const info = settings.getHttpPort();
+      expect(info).toEqual({
+        protocol: "http",
+        address: "address",
+        port: 8081,
+        toString: info.toString
+      });
+      expect(settings.getBestHost().toString()).toEqual("https://address:8080");
+
+      settings.set("httpsPort", false);
+      expect(settings.getBestHost().toString()).toEqual("http://address:8081");
+
+      settings.set("httpPort", false);
+      expect(settings.getBestHost().toString()).toEqual("/");
+    });
+
+    it("should return httpsOptions", () => {
+      expect((settings.httpsOptions as any).test).toEqual("/rest");
+    });
+
+    it("should return acceptMimes", () => {
+      expect(settings.acceptMimes[0]).toEqual("application/json");
+    });
+
+    it("should return statics", () => {
+      expect(settings.statics).toEqual({"/": "/public"});
+    });
+
+    describe("debug", () => {
+      it("should expose debug as initialized", () => {
+        expect(settings.debug).toEqual(true);
+      });
+
+      it("debug should be equal to the last set value", () => {
+        settings.debug = false;
+        expect(settings.debug).toEqual(false);
+      });
+    });
+
+    it("should return additionalProperties", () => {
+      expect(settings.additionalProperties).toEqual(false);
+    });
+
+    it("should return version", () => {
+      expect(settings.version).toEqual("1.0.0");
+    });
+
+    it("should return errors", () => {
+      expect(settings.errors).toEqual({headerName: "errors"});
+    });
+
+    it("should return routers", () => {
+      expect(settings.routers).toEqual({mergeParams: true});
+    });
+
+    it("should return jsonMapper settings", () => {
+      expect(settings.jsonMapper).toEqual({
+        disableUnsecureConstructor: true,
+        additionalProperties: false,
+        strictGroups: false
+      });
+    });
+
+    it("should return controllerScope", () => {
+      expect(settings.controllerScope).toEqual("singleton");
+    });
+
+    it("should return excluded patterns", () => {
+      expect(settings.exclude).toEqual(["./**/*.spec.ts"]);
+    });
+
+    describe("forEach()", () => {
+      it("should loop on items", () => {
+        const result = [];
+        settings.forEach((o: any) => result.push(o));
+        expect(!!result.length).toEqual(true);
+      });
+    });
+
+    describe("port", () => {
+      it("should set port", () => {
+        const settings = new PlatformConfiguration();
+
+        settings.set({port: 8081});
+
+        expect(settings.httpPort).toEqual(8081);
+        expect(settings.port).toEqual(8081);
+      });
+    });
+  });
+});

package/src/common/config/services/PlatformConfiguration.ts

@@ -0,0 +1,157 @@
+import {getHostInfoFromPort, isBoolean} from "@tsed/core";
+import {DIConfiguration, Injectable, ProviderScope, TokenProvider} from "@tsed/di";
+import {JsonMapperSettings} from "@tsed/json-mapper";
+import Https from "https";
+
+import {PlatformJsonMapperSettings} from "../interfaces/PlatformJsonMapperSettings.js";
+
+const rootDir = process.cwd();
+
+/**
+ * `PlatformConfiguration` contains all information about your Server configuration.
+ */
+@Injectable({
+  scope: ProviderScope.SINGLETON,
+  global: true
+})
+export class PlatformConfiguration extends DIConfiguration {
+  constructor() {
+    super({rootDir});
+  }
+
+  get port(): string | number | false {
+    return this.httpPort;
+  }
+
+  set port(value: string | number | false) {
+    this.httpPort = value;
+  }
+
+  get httpsOptions(): Https.ServerOptions {
+    return this.getRaw("httpsOptions");
+  }
+
+  set httpsOptions(value: Https.ServerOptions) {
+    this.setRaw("httpsOptions", value);
+  }
+
+  get httpPort(): string | number | false {
+    return this.getRaw("httpPort");
+  }
+
+  set httpPort(value: string | number | false) {
+    this.setRaw("httpPort", value);
+  }
+
+  get httpsPort(): string | number | false {
+    return this.getRaw("httpsPort");
+  }
+
+  set httpsPort(value: string | number | false) {
+    this.setRaw("httpsPort", value);
+  }
+
+  get mount(): Record<string, TokenProvider[]> {
+    return this.get("mount");
+  }
+
+  set mount(value: Record<string, TokenProvider[]>) {
+    this.setRaw("mount", value);
+  }
+
+  get statics(): Record<string, (any | string)[]> {
+    return this.getRaw("statics") || this.getRaw("serveStatic") || {};
+  }
+
+  set statics(value: Record<string, (any | string)[]>) {
+    this.setRaw("statics", value);
+  }
+
+  get acceptMimes(): string[] {
+    return this.getRaw("acceptMimes");
+  }
+
+  set acceptMimes(value: string[]) {
+    this.setRaw("acceptMimes", value || []);
+  }
+
+  get jsonMapper(): Partial<PlatformJsonMapperSettings> {
+    return {
+      ...JsonMapperSettings
+    };
+  }
+
+  set jsonMapper(options: Partial<PlatformJsonMapperSettings>) {
+    JsonMapperSettings.strictGroups = Boolean(options.strictGroups);
+    JsonMapperSettings.disableUnsecureConstructor = Boolean(options.disableUnsecureConstructor);
+    JsonMapperSettings.additionalProperties = Boolean(
+      isBoolean(options.additionalProperties) ? options.additionalProperties : options.additionalProperties === "accept"
+    );
+  }
+
+  get additionalProperties() {
+    return this.get("converter.additionalProperties") === "accept";
+  }
+
+  /**
+   *
+   * @returns {string|number}
+   */
+  getHttpPort(): ReturnType<typeof getHostInfoFromPort> {
+    return getHostInfoFromPort("http", this.getRaw("httpPort"));
+  }
+
+  /**
+   *
+   * @param settings
+   */
+  setHttpPort(settings: {address: string; port: number}) {
+    this.setRaw("httpPort", `${settings.address}:${settings.port}`);
+  }
+
+  /**
+   *
+   * @returns {string|number}
+   */
+  getHttpsPort() {
+    return getHostInfoFromPort("https", this.getRaw("httpsPort"));
+  }
+
+  /**
+   *
+   * @param settings
+   */
+  setHttpsPort(settings: {address: string; port: number}) {
+    this.setRaw("httpsPort", `${settings.address}:${settings.port}`);
+  }
+
+  getBestHost() {
+    const {httpsPort, httpPort} = this;
+
+    if (httpsPort) {
+      return this.getHttpsPort();
+    }
+
+    if (httpPort) {
+      return this.getHttpPort();
+    }
+
+    return {
+      toString() {
+        return "/";
+      }
+    };
+  }
+}
+
+declare global {
+  namespace TsED {
+    // @ts-ignore
+    interface Context {}
+
+    /**
+     * Here to allow extension on DIConfiguration base service
+     */
+    interface DIConfiguration extends PlatformConfiguration {}
+  }
+}

package/src/common/constants/routerOptions.ts

@@ -0,0 +1 @@
+export const ROUTER_OPTIONS = Symbol.for("ROUTER_OPTIONS");

package/src/common/decorators/PlatformProvider.ts

@@ -0,0 +1,14 @@
+import {Type} from "@tsed/core";
+
+import {adapter} from "../fn/adapter.js";
+import {PlatformAdapter} from "../services/PlatformAdapter.js";
+
+/**
+ * Register a new platform adapter.
+ * @decorator
+ */
+export function PlatformProvider() {
+  return (klass: Type<PlatformAdapter>) => {
+    adapter(klass);
+  };
+}

package/src/common/decorators/multer/multerFileSize.spec.ts

@@ -0,0 +1,22 @@
+import {Store} from "@tsed/core";
+
+import {PlatformMulterMiddleware} from "../../middlewares/PlatformMulterMiddleware.js";
+import {MulterFileSize} from "./multerFileSize.js";
+
+describe("MulterFileSize", () => {
+  it("should set the file size", () => {
+    class Test {
+      @MulterFileSize(100)
+      file() {}
+    }
+
+    const store = Store.fromMethod(Test, "file");
+    expect(store.get(PlatformMulterMiddleware)).toEqual({
+      options: {
+        limits: {
+          fileSize: 100
+        }
+      }
+    });
+  });
+});

package/src/common/decorators/multer/multerFileSize.ts

@@ -0,0 +1,32 @@
+import {MulterOptions} from "./multerOptions.js";
+
+/**
+ * Define file size limit.
+ *
+ * ```typescript
+ * import {Post} from "@tsed/schema";
+ * import {MulterOptions, MultipartFile} from "@tsed/platform-http";
+ * import {Controller} from "@tsed/di";
+ * import {Multer} from "@types/multer";
+ *
+ * type MulterFile = Express.Multer.File;
+ *
+ * @Controller('/')
+ * class MyCtrl {
+ *   @Post('/file2')
+ *   @MulterFileSize(1024) // (Ko). Applied for all fields
+ *   private uploadFile(@MultipartFile("file1") file: MulterFile, @MultipartFile("file2") file2: MulterFile) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * > See the tutorial on the [multer configuration](/docs/upload-files.md).
+ * @param fileSize
+ * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor}
+ * @decorator
+ * @multer
+ */
+export function MulterFileSize(fileSize: number): MethodDecorator {
+  return MulterOptions({limits: {fileSize}});
+}

package/src/common/decorators/multer/multerOptions.spec.ts

@@ -0,0 +1,21 @@
+import {Store} from "@tsed/core";
+
+import {PlatformMulterMiddleware} from "../../middlewares/PlatformMulterMiddleware.js";
+import {MulterOptions} from "./multerOptions.js";
+
+describe("@MulterOptions()", () => {
+  it("should store metadata", () => {
+    class Test {
+      @MulterOptions({dest: "/"})
+      test() {}
+    }
+
+    const store = Store.fromMethod(Test.prototype, "test");
+
+    expect(store.get(PlatformMulterMiddleware)).toEqual({
+      options: {
+        dest: "/"
+      }
+    });
+  });
+});

package/src/common/decorators/multer/multerOptions.ts

@@ -0,0 +1,53 @@
+import {StoreMerge} from "@tsed/core";
+
+import {PlatformMulterSettings} from "../../config/interfaces/PlatformMulterSettings.js";
+import {PlatformMulterMiddleware} from "../../middlewares/PlatformMulterMiddleware.js";
+
+/**
+ * Define multer option for all MultipartFile
+ *
+ * ```typescript
+ * import {PlatformMulterFile, MultipartFile, MulterOptions} from "@tsed/platform-http";
+ * import {Controller} from "@tsed/di";
+ * import {Post} from "@tsed/schema";
+ *
+ * @Controller('/')
+ * class MyCtrl {
+ *   @Post('/file')
+ *   private uploadFile(@MultipartFile("file1") file: PlatformMulterFile) {
+ *
+ *   }
+ *
+ *   @Post('/file')
+ *   @MulterOptions({dest: "/other-dir"})
+ *   private uploadFile(@MultipartFile("file1") file: PlatformMulterFile) {
+ *
+ *   }
+ *
+ *   @Post('/file2')
+ *   @MulterOptions({dest: "/other-dir"})
+ *   private uploadFile(@MultipartFile("file1") file: PlatformMulterFile, @MultipartFile("file2") file2: PlatformMulterFile) {
+ *
+ *   }
+ *
+ *   @Post('/files')
+ *   private uploadFile(@MultipartFile("file1") files: PlatformMulterFile[]) {
+ *
+ *   }
+ * }
+ * ```
+ *
+ * See the tutorial on the [multer configuration](/docs/upload-files.md).
+ *
+ * @param {multer.Options} options
+ * @returns {(target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor}
+ * @decorator
+ * @multer
+ */
+export function MulterOptions(options: PlatformMulterSettings): MethodDecorator {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    StoreMerge(PlatformMulterMiddleware, {options})(target, propertyKey, descriptor);
+
+    return descriptor;
+  };
+}