@tsed/schema 8.0.0 → 8.0.2

package/src/utils/generateSpec.ts

@@ -0,0 +1,54 @@
+import {getValue} from "@tsed/core";
+import {OpenSpec2, OpenSpec3} from "@tsed/openspec";
+
+import {SpecTypes} from "../domain/SpecTypes.js";
+import {getSpec, JsonTokenOptions, SpecSerializerOptions} from "./getSpec.js";
+import {getSpecTypeFromSpec} from "./getSpecType.js";
+import {mapOpenSpec} from "./mapOpenSpec.js";
+import {mergeSpec} from "./mergeSpec.js";
+import {transformToOS2} from "./transformToOS2.js";
+
+export interface GenerateSpecOptions extends Omit<SpecSerializerOptions, "specType"> {
+  tokens: JsonTokenOptions;
+  version?: string;
+  acceptMimes?: string;
+  specVersion?: string;
+  spec?: any;
+  fileSpec?: any;
+  sortPaths?: boolean;
+}
+
+/**
+ * Generate OpenAPI spec from multiple sources (models, files, conf)
+ * @param tokens
+ * @param options
+ */
+export function generateSpec({tokens, ...options}: GenerateSpecOptions): OpenSpec2 | OpenSpec3 {
+  const {version = "1.0.0", acceptMimes, fileSpec = {}, specVersion} = options;
+
+  const defaultSpec = mapOpenSpec(getValue(options, "spec", {}), {
+    fileSpec,
+    version,
+    specVersion,
+    acceptMimes
+  });
+
+  const specType = getSpecTypeFromSpec(defaultSpec);
+
+  let controllersSpec: any = getSpec(tokens, options);
+  const spec = mergeSpec(defaultSpec, controllersSpec) as OpenSpec2 | OpenSpec3;
+
+  if (options.sortPaths) {
+    spec.paths = Object.fromEntries(
+      Object.entries(spec.paths!).sort(([k1], [k2]) => {
+        return k1.localeCompare(k2);
+      })
+    );
+  }
+
+  if (specType === SpecTypes.SWAGGER) {
+    return transformToOS2(spec) as any;
+  }
+
+  return spec;
+}

package/src/utils/generics.ts

@@ -0,0 +1,83 @@
+import {Type} from "@tsed/core";
+
+import {JsonSchema} from "../domain/JsonSchema.js";
+
+export type GenericValue = Type<any> | JsonSchema | any;
+
+/**
+ * @ignore
+ */
+export type GenericsMap = Map<string, GenericValue>;
+
+/**
+ * @ignore
+ */
+export interface GenericTypes {
+  genericTypes: Type<any>[];
+
+  [key: string]: any;
+}
+
+/**
+ * @ignore
+ */
+export interface GenericLabels {
+  genericLabels: string[];
+
+  [key: string]: any;
+}
+
+/**
+ * @ignore
+ */
+export interface NestedGenerics {
+  nestedGenerics: GenericValue[][];
+
+  [key: string]: any;
+}
+
+/**
+ * @ignore
+ */
+export interface GenericsContext extends GenericTypes, GenericLabels, NestedGenerics {
+  generics: GenericsMap;
+}
+
+/**
+ * @ignore
+ * @param genericLabels
+ * @param genericTypes
+ */
+export function getGenericsMap(genericLabels: string[], genericTypes: GenericValue[]): GenericsMap {
+  return genericLabels.reduce((map: Map<string, any>, item: string, index: number) => map.set(item, genericTypes[index]), new Map());
+}
+
+/**
+ * @ignore
+ * @param options
+ */
+export function mapGenericsOptions(options: Partial<GenericTypes & GenericLabels>) {
+  if (options.genericLabels && options.genericTypes) {
+    const {genericLabels, genericTypes, ...ops} = options;
+
+    return {
+      ...ops,
+      generics: getGenericsMap(genericLabels, genericTypes)
+    };
+  }
+
+  return options;
+}
+
+/**
+ * @ignore
+ * @param value
+ */
+export function popGenerics(value: NestedGenerics): NestedGenerics & GenericTypes {
+  const [genericTypes, ...out] = value.nestedGenerics;
+
+  return {
+    genericTypes,
+    nestedGenerics: out
+  };
+}

package/src/utils/getComputedType.spec.ts

@@ -0,0 +1,45 @@
+import {getComputedType} from "./getComputedType.js";
+
+describe("getComputedType", () => {
+  it("should return the right class (String)", () => {
+    expect(getComputedType(String)).toEqual(String);
+  });
+  it("should return the right class (Number)", () => {
+    expect(getComputedType(Number)).toEqual(Number);
+  });
+  it("should return the right class (Boolean)", () => {
+    expect(getComputedType(Boolean)).toEqual(Boolean);
+  });
+  it("should return the right class (Symbol)", () => {
+    expect(getComputedType(Symbol)).toEqual(Symbol);
+  });
+  it("should return the right class (Date)", () => {
+    expect(getComputedType(Date)).toEqual(Date);
+  });
+  it("should return the right class (Array)", () => {
+    expect(getComputedType(Array)).toEqual(Array);
+  });
+  it("should return the right class (Map)", () => {
+    expect(getComputedType(Map)).toEqual(Map);
+  });
+  it("should return the right class (Set)", () => {
+    expect(getComputedType(Set)).toEqual(Set);
+  });
+  it("should return the right class (Promise)", () => {
+    expect(getComputedType(Promise)).toEqual(Object);
+  });
+  it("should return the right class (class with arrow)", () => {
+    class Test {}
+
+    expect(getComputedType(() => Test)).toEqual(Test);
+  });
+  it("should return the right class (class)", () => {
+    class Test {}
+
+    expect(getComputedType(Test)).toEqual(Test);
+  });
+
+  it("should return the right class (undefined)", () => {
+    expect(getComputedType(undefined)).toEqual(undefined);
+  });
+});

package/src/utils/getComputedType.ts

@@ -0,0 +1,39 @@
+import {
+  classOf,
+  isArrowFn,
+  isClass,
+  isClassObject,
+  isCollection,
+  isDate,
+  isFunction,
+  isPrimitiveOrPrimitiveClass,
+  isPromise,
+  isSymbol,
+  Type
+} from "@tsed/core";
+
+/**
+ * @ignore
+ */
+export function getComputedType(target: any): Type<any> {
+  if (isPromise(target) || target === Function) {
+    return Object;
+  }
+
+  if (
+    isClass(target) ||
+    isSymbol(target) ||
+    isPrimitiveOrPrimitiveClass(target) ||
+    isClassObject(target) ||
+    isDate(target) ||
+    isCollection(target)
+  ) {
+    return classOf(target);
+  }
+
+  if (isArrowFn(target)) {
+    return (target as any)();
+  }
+
+  return target;
+}

package/src/utils/getInheritedStores.spec.ts

@@ -0,0 +1,47 @@
+import {StoreSet} from "@tsed/core";
+
+import {OperationPath} from "../decorators/operations/operationPath.js";
+import {getInheritedStores} from "./getInheritedStores.js";
+
+describe("getInheritedStores", () => {
+  it("should return inherited store", () => {
+    class Test2 {
+      @StoreSet("test", "Test2")
+      @OperationPath("GET")
+      method1(): any {}
+    }
+
+    class Test1 extends Test2 {
+      @StoreSet("test", "Test1")
+      @OperationPath("GET")
+      method(): any {}
+
+      @StoreSet("test", "Test1")
+      @OperationPath("GET")
+      method2(): any {}
+    }
+
+    class Test extends Test1 {
+      @StoreSet("test", "Test")
+      @OperationPath("GET")
+      method(): any {}
+
+      @StoreSet("test", "Test")
+      @OperationPath("GET")
+      method3() {}
+    }
+
+    const stores = [...getInheritedStores(Test).entries()];
+
+    expect(stores[0][0]).toEqual(Test);
+    expect(stores[1][0]).toEqual(Test1);
+    expect(stores[2][0]).toEqual(Test2);
+
+    const entity1 = stores[0][1].children.get("method");
+    const entity2 = stores[1][1].children.get("method");
+    const entity3 = stores[2][1].children.get("method");
+    expect(entity1?.store.get("test")).toEqual("Test");
+    expect(entity2?.store.get("test")).toEqual("Test1");
+    expect(entity3?.store.get("test")).toEqual(undefined);
+  });
+});

package/src/utils/getInheritedStores.ts

@@ -0,0 +1,23 @@
+import {ancestorsOf, Type} from "@tsed/core";
+
+import type {JsonClassStore} from "../domain/JsonClassStore.js";
+import {getJsonEntityStore} from "./getJsonEntityStore.js";
+
+/**
+ * Return store and his inherited stores
+ * @param target
+ * @ignore
+ */
+export function getInheritedStores(target: Type<any> | any): Map<Type<any>, JsonClassStore> {
+  const store: JsonClassStore = target.isStore ? target : getJsonEntityStore<JsonClassStore>(target);
+
+  if (!store.$inherited) {
+    store.$inherited = ancestorsOf(store.target)
+      .reverse()
+      .reduce((context, model) => {
+        return context.set(model, getJsonEntityStore(model));
+      }, new Map());
+  }
+
+  return store.$inherited;
+}

package/src/utils/getJsonEntityStore.ts

@@ -0,0 +1,36 @@
+import {DecoratorTypes, Type} from "@tsed/core";
+
+import {JsonClassStore} from "../domain/JsonClassStore.js";
+import {JsonEntitiesContainer, JsonEntityStore} from "../domain/JsonEntityStore.js";
+import {JsonMethodStore} from "../domain/JsonMethodStore.js";
+import {JsonParameterStore} from "../domain/JsonParameterStore.js";
+import {JsonPropertyStore} from "../domain/JsonPropertyStore.js";
+
+JsonEntitiesContainer.set(DecoratorTypes.CLASS, JsonClassStore);
+JsonEntitiesContainer.set(DecoratorTypes.PROP, JsonPropertyStore);
+JsonEntitiesContainer.set(DecoratorTypes.PARAM, JsonParameterStore);
+JsonEntitiesContainer.set(DecoratorTypes.METHOD, JsonMethodStore);
+
+/**
+ * Get entity store from decorator args
+ * @param target
+ */
+export function getJsonEntityStore<T extends JsonClassStore = JsonClassStore>(target: Type<any>): T;
+export function getJsonEntityStore<T extends JsonPropertyStore = JsonPropertyStore>(
+  target: Type<any> | any,
+  propertyKey: string | symbol
+): T;
+export function getJsonEntityStore<T extends JsonParameterStore = JsonParameterStore>(
+  target: Type<any> | any,
+  propertyKey: string | symbol,
+  index: number
+): T;
+export function getJsonEntityStore<T extends JsonMethodStore = JsonMethodStore>(
+  target: Type<any> | any,
+  propertyKey: string | symbol,
+  descriptor: PropertyDescriptor
+): T;
+export function getJsonEntityStore<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T;
+export function getJsonEntityStore<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T {
+  return JsonEntityStore.from<T>(...args);
+}

package/src/utils/getJsonPathParameters.spec.ts

@@ -0,0 +1,126 @@
+import {getJsonPathParameters} from "./getJsonPathParameters.js";
+
+describe("getJsonPathParameters", () => {
+  it("should return params and path(1)", () => {
+    expect(getJsonPathParameters("/rest/", "/get/:path1/:path2?")).toEqual([
+      {
+        path: "/rest/get/{path1}",
+        parameters: [
+          {
+            in: "path",
+            name: "path1",
+            required: true,
+            type: "string"
+          }
+        ]
+      },
+      {
+        path: "/rest/get/{path1}/{path2}",
+        parameters: [
+          {
+            in: "path",
+            name: "path1",
+            required: true,
+            type: "string"
+          },
+          {
+            in: "path",
+            name: "path2",
+            required: true,
+            type: "string"
+          }
+        ]
+      }
+    ]);
+  });
+  it("should return params and path(2)", () => {
+    expect(getJsonPathParameters("/rest/", "/get/:path1/:path2")).toEqual([
+      {
+        path: "/rest/get/{path1}/{path2}",
+        parameters: [
+          {
+            in: "path",
+            name: "path1",
+            required: true,
+            type: "string"
+          },
+          {
+            in: "path",
+            name: "path2",
+            required: true,
+            type: "string"
+          }
+        ]
+      }
+    ]);
+  });
+  it("should return params and path(3)", () => {
+    expect(getJsonPathParameters("/rest/", "/get/path1/path2")).toEqual([
+      {
+        path: "/rest/get/path1/path2",
+        parameters: []
+      }
+    ]);
+  });
+  it("should return params and path(4)", () => {
+    expect(getJsonPathParameters("/rest/calendar/", "/")).toEqual([
+      {
+        path: "/rest/calendar",
+        parameters: []
+      }
+    ]);
+  });
+  it("should return params and path /file/:filename.json", () => {
+    expect(getJsonPathParameters("/rest/", "/file/:filename.json")).toEqual([
+      {
+        path: "/rest/file/{filename}.json",
+        parameters: [
+          {
+            in: "path",
+            name: "filename",
+            required: true,
+            type: "string"
+          }
+        ]
+      }
+    ]);
+  });
+  it("should return params and path /category/:category([a-zA-Z/_-]+).json", () => {
+    expect(getJsonPathParameters("/rest/", "/category/:category([a-zA-Z/_-]+).json")).toEqual([
+      {
+        path: "/rest/category/{category}.json",
+        parameters: [
+          {
+            in: "path",
+            name: "category",
+            required: true,
+            type: "string"
+          }
+        ]
+      }
+    ]);
+  });
+  it("should return params and path /path/JQ=:id", () => {
+    expect(getJsonPathParameters("/rest/", "/path/JQ=:id")).toEqual([
+      {
+        path: "/rest/path/JQ={id}",
+        parameters: [
+          {
+            in: "path",
+            name: "id",
+            required: true,
+            type: "string"
+          }
+        ]
+      }
+    ]);
+  });
+  it("should return params and path regexp", () => {
+    expect(getJsonPathParameters("/rest/", /\*json$/)).toEqual([
+      {
+        parameters: [],
+        path: "/rest/*json$"
+      }
+    ]);
+  });
+});

package/src/utils/getJsonPathParameters.ts

@@ -0,0 +1,97 @@
+/**
+ * @ignore
+ */
+function getVariable(subpath: string) {
+  const [prefix, right] = subpath.split("=");
+  const splited = (right || prefix).split(".");
+  const name = splited.splice(0, 1)[0];
+
+  return {
+    prefix: right && prefix ? `${prefix}=` : "",
+    name,
+    postfix: splited.length ? `.${splited.join(".")}` : ""
+  };
+}
+
+function parseUrl(key: string) {
+  let inCapture = 0;
+
+  return key
+    .split("")
+    .filter((c) => {
+      if (c === "(") {
+        inCapture++;
+      }
+
+      const result = inCapture === 0;
+
+      if (c === ")") {
+        inCapture--;
+      }
+
+      return result;
+    })
+    .join("")
+    .split("/")
+    .filter((o) => !!o);
+}
+
+/**
+ * @ignore
+ */
+export function getJsonPathParameters(base: string, path: string | RegExp | (string | RegExp)[] = ""): {path: string; parameters: any[]}[] {
+  if (path instanceof RegExp) {
+    path = path.toString().replace(/^\//g, "").replace(/\/$/g, "").replace(/\\/g, "");
+  }
+
+  const params: any[] = [];
+  const paths: any[] = [];
+  let isOptional = false;
+  let current = "";
+
+  parseUrl(`${base}${path}`).map((key) => {
+    const subpath = key.replace(":", "").replace("?", "");
+
+    if (key.includes(":")) {
+      const optional = key.includes("?");
+
+      // Append previous config
+      if (optional && !isOptional) {
+        isOptional = true;
+
+        paths.push({
+          path: current,
+          parameters: [].concat(params as any)
+        });
+      }
+
+      const {prefix, name, postfix} = getVariable(subpath);
+      current += `/${prefix}{${name}}${postfix}`;
+
+      params.push({
+        in: "path",
+        name,
+        type: "string",
+        required: true
+      });
+
+      if (optional && isOptional) {
+        paths.push({
+          path: current,
+          parameters: [].concat(params as any)
+        });
+      }
+    } else {
+      current += `/${key}`;
+    }
+  });
+
+  return paths.length
+    ? paths
+    : [
+        {
+          path: current,
+          parameters: [].concat(params as any)
+        }
+      ];
+}