@tsed/schema 8.0.1 → 8.0.3

package/src/utils/getJsonSchema.ts

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

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

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

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

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

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

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

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