@tsed/schema 8.11.1 → 8.12.0-rc.1

package/src/utils/generateSpec.ts

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

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

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

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

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

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

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

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

@@ -1,97 +0,0 @@
-/**
- * @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)
-        }
-      ];
-}