@tsed/schema 8.11.0 → 8.11.2-rc.1

package/src/utils/getJsonSchema.ts

@@ -1,69 +0,0 @@
-import "../components/index.js";
-
-import {getValue, Type} from "@tsed/core";
-
-import type {JsonEntityStore} from "../domain/JsonEntityStore.js";
-import {SpecTypes} from "../domain/SpecTypes.js";
-import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions.js";
-import {execMapper} from "../registries/JsonSchemaMapperContainer.js";
-import {getJsonEntityStore} from "./getJsonEntityStore.js";
-
-/**
- * @ignore
- */
-const CACHE_KEY = "$cache:schemes";
-
-/**
- * @ignore
- */
-function getKey(options: any) {
-  return JSON.stringify(options);
-}
-
-/**
- * @ignore
- */
-function get(entity: JsonEntityStore, options: any) {
-  const cache: Map<string, any> = entity.store.get(CACHE_KEY) || new Map();
-  const key = getKey(options);
-
-  if (!cache.has(key)) {
-    const schema = execMapper("schema", [entity.schema], options);
-
-    if (Object.keys(getValue(options, "components.schemas", {})).length) {
-      schema.definitions = options.components.schemas;
-    }
-
-    cache.set(key, schema);
-  }
-
-  entity.store.set(CACHE_KEY, cache);
-
-  return cache.get(key);
-}
-
-export function getJsonSchema(model: Type<any> | any, options: JsonSchemaOptions = {}) {
-  const entity = getJsonEntityStore(model);
-  const specType = options.specType || SpecTypes.JSON;
-  options = {
-    endpoint: true,
-    groups: [],
-    inlineEnums: specType === SpecTypes.JSON,
-    ...options,
-    specType,
-    components: {
-      schemas: {}
-    }
-  };
-
-  if (entity.decoratorType === "parameter") {
-    options = {
-      ...options,
-      genericTypes: entity.nestedGenerics[0],
-      nestedGenerics: entity.nestedGenerics,
-      groups: entity.parameter?.groups
-    };
-  }
-
-  return get(entity, options);
-}

package/src/utils/getJsonType.spec.ts

@@ -1,28 +0,0 @@
-import {getJsonType} from "./getJsonType.js";
-
-describe("getJsonType", () => {
-  it("should return file", () => {
-    expect(getJsonType("file")).toBe("file");
-  });
-  it("should return generic", () => {
-    expect(getJsonType("test")).toBe("generic");
-  });
-  it("should return ['generic']", () => {
-    expect(getJsonType(["test"])).toEqual(["generic"]);
-  });
-  it("should return array", () => {
-    expect(getJsonType(Array)).toBe("array");
-  });
-  it("should return string", () => {
-    expect(getJsonType(new Date())).toBe("string");
-  });
-  it("should return object", () => {
-    expect(getJsonType({test: "test"})).toBe("object");
-  });
-  it("should return null", () => {
-    expect(getJsonType(null)).toBe("null");
-  });
-  it("should return number", () => {
-    expect(getJsonType(5)).toBe("number");
-  });
-});

package/src/utils/getJsonType.ts

@@ -1,46 +0,0 @@
-import {isArray, isBuffer, isDate, isPrimitiveOrPrimitiveClass, primitiveOf} from "@tsed/core";
-
-/**
- * @ignore
- */
-export const JSON_TYPES = ["string", "number", "integer", "boolean", "object", "array", "null", "any"];
-
-export function getJsonType(value: any): string {
-  if (value === null) {
-    return "null";
-  }
-
-  if (isPrimitiveOrPrimitiveClass(value)) {
-    if (JSON_TYPES.indexOf(value as string) > -1) {
-      return value;
-    }
-
-    if (typeof value === "string") {
-      if (value === "file") {
-        return "file";
-      }
-
-      return "generic";
-    }
-
-    return primitiveOf(value);
-  }
-
-  if (value === Array) {
-    return "array";
-  }
-
-  if (isArray(value)) {
-    return value.map(getJsonType) as any;
-  }
-
-  if (value === Set) {
-    return "array";
-  }
-
-  if (isDate(value) || isBuffer(value)) {
-    return "string";
-  }
-
-  return "object";
-}

package/src/utils/getOperationsRoutes.spec.ts

@@ -1,284 +0,0 @@
-import {StoreSet} from "@tsed/core";
-
-import {Children} from "../decorators/class/children.js";
-import {In} from "../decorators/operations/in.js";
-import {Path} from "../decorators/operations/path.js";
-import {All, Get} from "../decorators/operations/route.js";
-import {JsonOperationRoute} from "../domain/JsonOperationRoute.js";
-import {getOperationsRoutes} from "./getOperationsRoutes.js";
-
-function getData(operationRoute: JsonOperationRoute) {
-  return {
-    token: operationRoute.token,
-    target: operationRoute.endpoint.token,
-    propertyKey: operationRoute.propertyKey,
-    path: operationRoute.path,
-    fullPath: operationRoute.fullPath,
-    method: operationRoute.method,
-    storeValue: operationRoute.store.get("test")
-  };
-}
-
-describe("getOperationsRoutes()", () => {
-  it("should return operation with his path and methods", () => {
-    // GIVEN
-    @Path("/test")
-    class Test2 {
-      @Get("/")
-      @StoreSet("test", "Test2")
-      method1(): any {}
-    }
-
-    @Path("/test")
-    class Test1 extends Test2 {
-      @Get("/")
-      @StoreSet("test", "Test1")
-      method(): any {}
-
-      @Get("/")
-      @StoreSet("test", "Test1")
-      method2(): any {}
-    }
-
-    @Path("/test")
-    class Test extends Test1 {
-      @Get("/")
-      @StoreSet("test", "Test")
-      method(): any {}
-
-      @Get("/")
-      @StoreSet("test", "Test")
-      method3() {}
-
-      @All("/all")
-      all() {}
-
-      @StoreSet("test", "test-ignore")
-      shouldBeIgnored(@In("any") ctx: any) {}
-    }
-
-    const operationsRoutes = getOperationsRoutes(Test);
-
-    expect(operationsRoutes.map(getData)).toEqual([
-      {
-        fullPath: "/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "Test",
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method3",
-        storeValue: "Test",
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/test/all",
-        method: "ALL",
-        path: "/all",
-        propertyKey: "all",
-        storeValue: undefined,
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method2",
-        storeValue: "Test1",
-        target: Test1,
-        token: Test
-      },
-      {
-        fullPath: "/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method1",
-        storeValue: "Test2",
-        target: Test2,
-        token: Test
-      }
-    ]);
-  });
-  it("should ignore method not decorated with the right decorator", () => {
-    // GIVEN
-    @Path("/test")
-    class Test {
-      @StoreSet("test", "test-ignore")
-      shouldBeIgnored(@In("any") ctx: any) {}
-    }
-
-    const operationsRoutes = getOperationsRoutes(Test);
-
-    expect(operationsRoutes.map(getData)).toEqual([]);
-  });
-  it("should return operations routes with children", () => {
-    @Path("/deep")
-    class TestChild2 {
-      @Get("/")
-      @StoreSet("test", "deep")
-      method(): any {}
-    }
-
-    @Path("/children")
-    @Children(TestChild2)
-    class TestChild {
-      @Get("/")
-      @StoreSet("test", "children")
-      method(): any {}
-    }
-
-    @Path("/test")
-    @Children(TestChild)
-    class Test {
-      @Get("/")
-      @StoreSet("test", "Test")
-      method(): any {}
-
-      @Get("/")
-      @StoreSet("test", "Test")
-      method3() {}
-
-      @All("/all")
-      all() {}
-    }
-
-    const operationsRoutes = getOperationsRoutes(Test, {withChildren: true});
-
-    expect(operationsRoutes.map(getData)).toEqual([
-      {
-        fullPath: "/test/children/deep",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "deep",
-        target: TestChild2,
-        token: TestChild2
-      },
-      {
-        fullPath: "/test/children",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "children",
-        target: TestChild,
-        token: TestChild
-      },
-      {
-        fullPath: "/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "Test",
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method3",
-        storeValue: "Test",
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/test/all",
-        method: "ALL",
-        path: "/all",
-        propertyKey: "all",
-        storeValue: undefined,
-        target: Test,
-        token: Test
-      }
-    ]);
-  });
-  it("should return operations routes with children and basePath", () => {
-    @Path("/deep")
-    class TestChild2 {
-      @Get("/")
-      @StoreSet("test", "deep")
-      method(): any {}
-    }
-
-    @Path("/children")
-    @Children(TestChild2)
-    class TestChild {
-      @Get("/")
-      @StoreSet("test", "children")
-      method(): any {}
-    }
-
-    @Path("/test")
-    @Children(TestChild)
-    class Test {
-      @Get("/")
-      @StoreSet("test", "Test")
-      method(): any {}
-
-      @Get("/")
-      @StoreSet("test", "Test")
-      method3() {}
-
-      @All("/all")
-      all() {}
-    }
-
-    const operationsRoutes = getOperationsRoutes(Test, {withChildren: true, basePath: "/rest"});
-
-    expect(operationsRoutes.map(getData)).toEqual([
-      {
-        fullPath: "/rest/test/children/deep",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "deep",
-        target: TestChild2,
-        token: TestChild2
-      },
-      {
-        fullPath: "/rest/test/children",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "children",
-        target: TestChild,
-        token: TestChild
-      },
-      {
-        fullPath: "/rest/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method",
-        storeValue: "Test",
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/rest/test",
-        method: "GET",
-        path: "/",
-        propertyKey: "method3",
-        storeValue: "Test",
-        target: Test,
-        token: Test
-      },
-      {
-        fullPath: "/rest/test/all",
-        method: "ALL",
-        path: "/all",
-        propertyKey: "all",
-        storeValue: undefined,
-        target: Test,
-        token: Test
-      }
-    ]);
-  });
-});

package/src/utils/getOperationsRoutes.ts

@@ -1,56 +0,0 @@
-import {Type} from "@tsed/core";
-
-import {OperationVerbs} from "../constants/OperationVerbs.js";
-import {JsonEntityStore} from "../domain/JsonEntityStore.js";
-import {JsonMethodStore} from "../domain/JsonMethodStore.js";
-import {JsonOperationRoute} from "../domain/JsonOperationRoute.js";
-import {concatPath} from "./concatPath.js";
-import {getJsonEntityStore} from "./getJsonEntityStore.js";
-import {getOperationsStores} from "./getOperationsStores.js";
-
-export interface GetOperationsRoutesOptions {
-  withChildren?: boolean;
-  basePath?: string;
-  allowedVerbs?: OperationVerbs[];
-}
-
-export function getOperationsRoutes<Entity extends JsonMethodStore = JsonMethodStore>(
-  token: Type<any> | any,
-  options: GetOperationsRoutesOptions = {}
-): JsonOperationRoute<Entity>[] {
-  const store: JsonEntityStore = token.isStore ? token : getJsonEntityStore(token);
-  const basePath = concatPath(options.basePath, store.path);
-  let operationsRoutes: JsonOperationRoute<Entity>[] = [];
-
-  if (options.withChildren) {
-    const children = store.get<Type[]>("childrenControllers", []);
-
-    operationsRoutes = children.reduce((operationsRoutes, token) => {
-      return operationsRoutes.concat(
-        getOperationsRoutes(token, {
-          ...options,
-          basePath
-        })
-      );
-    }, operationsRoutes);
-  }
-
-  return [...getOperationsStores(token).values()].reduce((routes, endpoint) => {
-    const {operation} = endpoint;
-
-    if (operation) {
-      operation.getAllowedOperationPath(options.allowedVerbs).forEach((operationPath) => {
-        routes.push(
-          new JsonOperationRoute<Entity>({
-            basePath,
-            token,
-            endpoint,
-            operationPath
-          })
-        );
-      });
-    }
-
-    return routes;
-  }, operationsRoutes);
-}

package/src/utils/getOperationsStore.spec.ts

@@ -1,47 +0,0 @@
-import {StoreSet} from "@tsed/core";
-
-import {getOperationsStores, OperationPath} from "../index.js";
-
-describe("getOperationsStore", () => {
-  it("should return operation with right order", () => {
-    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 = [...getOperationsStores(Test).entries()];
-
-    expect(stores[0][0]).toBe("method");
-    expect(stores[0][1].store.get("test")).toBe("Test");
-
-    expect(stores[1][0]).toBe("method3");
-    expect(stores[1][1].store.get("test")).toBe("Test");
-
-    expect(stores[2][0]).toBe("method2");
-    expect(stores[2][1].store.get("test")).toBe("Test1");
-
-    expect(stores[3][0]).toBe("method1");
-    expect(stores[3][1].store.get("test")).toBe("Test2");
-  });
-});

package/src/utils/getOperationsStores.ts

@@ -1,37 +0,0 @@
-import {Type} from "@tsed/core";
-
-import type {JsonClassStore} from "../domain/JsonClassStore.js";
-import {JsonMethodStore} from "../domain/JsonMethodStore.js";
-import {JsonOperationPathsMap} from "../domain/JsonOperationPathsMap.js";
-import {getInheritedStores} from "./getInheritedStores.js";
-import {getJsonEntityStore} from "./getJsonEntityStore.js";
-
-/**
- * @ignore
- */
-export function getOperationsStores<T extends JsonMethodStore = JsonMethodStore>(target: Type<any> | any): Map<string, T> {
-  const store: JsonClassStore = target.isStore ? target : getJsonEntityStore(target);
-
-  if (!store.$operations) {
-    const operationPaths = new JsonOperationPathsMap();
-    store.$operations = new Map<string, T>();
-
-    getInheritedStores(store).forEach((currentStore) => {
-      currentStore.children.forEach((propStore) => {
-        if (propStore instanceof JsonMethodStore && !store.$operations.has(propStore.propertyKey)) {
-          store.$operations.set(propStore.propertyKey, propStore);
-        }
-      });
-    });
-
-    store.$operations.forEach((store: JsonMethodStore) => {
-      store.operation.operationPaths.forEach((operationPath) => {
-        operationPaths.setOperationPath(operationPath);
-      });
-    });
-
-    operationPaths.clear();
-  }
-
-  return store.$operations;
-}

package/src/utils/getPropertiesStores.spec.ts

@@ -1,138 +0,0 @@
-import {Email} from "../decorators/common/format.js";
-import {Ignore} from "../decorators/common/ignore.js";
-import {Property} from "../decorators/common/property.js";
-import {Required} from "../decorators/common/required.js";
-import {getProperties, getPropertiesStores} from "./getPropertiesStores.js";
-
-class Base {
-  @Property()
-  id: string;
-
-  @Email()
-  email: string;
-}
-
-class Child extends Base {
-  @Required()
-  declare id: string;
-
-  @Property()
-  name: string;
-}
-
-describe("getProperties()", () => {
-  it("should return properties", () => {
-    const properties = getPropertiesStores(Child);
-    expect(Array.from(properties.keys())).toEqual(["id", "name", "email"]);
-    const properties2 = getPropertiesStores(Child);
-    expect(Array.from(properties2.keys())).toEqual(["id", "name", "email"]);
-  });
-
-  describe("getProperties()", () => {
-    class Parent {
-      @Ignore()
-      _id: string;
-
-      @Property()
-      id: string;
-
-      @Property()
-      name: string;
-
-      @Property()
-      categoryId: string;
-    }
-
-    class Children extends Parent {
-      @Property()
-      declare id: string;
-
-      @Property()
-      test: string;
-
-      @Ignore()
-      declare categoryId: string;
-    }
-
-    class Children2 extends Parent {
-      @Property()
-      declare id: string;
-
-      @Property()
-      test: string;
-
-      @Property()
-      declare categoryId: string;
-    }
-
-    describe("when is the Children class", () => {
-      it("should have a property id metadata from Children class", () => {
-        const result = getProperties(Children);
-        expect(result.get("id")!.targetName).toBe("Children");
-      });
-
-      it("should have a property name metadata from Parent class", () => {
-        const result = getProperties(Children);
-        expect(result.get("name")!.targetName).toBe("Parent");
-      });
-
-      it("should have a property test metadata from Parent class", () => {
-        const result = getProperties(Children);
-        expect(result.get("test")!.targetName).toBe("Children");
-      });
-
-      it("should not have a property categoryId metadata from Parent class", () => {
-        const result = getProperties(Children);
-        expect(result.has("categoryId")).toEqual(false);
-      });
-    });
-
-    describe("when is the Children2 class", () => {
-      it("should have a property id metadata from Children class", () => {
-        const result = getProperties(Children2);
-        expect(result.get("id")!.targetName).toBe("Children2");
-      });
-
-      it("should have a property name metadata from Parent class", () => {
-        const result = getProperties(Children2);
-        expect(result.get("name")!.targetName).toBe("Parent");
-      });
-
-      it("should have a property test metadata from Parent class", () => {
-        const result = getProperties(Children2);
-        expect(result.get("test")!.targetName).toBe("Children2");
-      });
-
-      it("should have a property categoryId metadata from Parent class", () => {
-        const result = getProperties(Children2);
-        expect(result.get("categoryId")!.targetName).toBe("Children2");
-      });
-    });
-
-    describe("when is the Parent class", () => {
-      it("should have a property test metadata from Parent class", () => {
-        const result = getProperties(Parent);
-        expect(result.has("test")).toBe(false);
-      });
-
-      it("should have a property id metadata from Children class", () => {
-        const result = getProperties(Parent);
-        expect(result.get("id")!.targetName).toBe("Parent");
-      });
-
-      it("should have a property name metadata from Parent class", () => {
-        const result = getProperties(Parent);
-        expect(result.get("name")!.targetName).toBe("Parent");
-      });
-
-      it("should not have a property _id metadata from Parent class (because ignoreProperty is used)", () => {
-        const result = getProperties(Parent);
-        expect(result.has("_id")).toBe(false);
-      });
-      it("should not have a property categoryId metadata from Parent class", () => {
-        const result = getProperties(Parent);
-        expect(result.has("categoryId")).toBe(true);
-      });
-    });
-  });
-});