@tsed/schema 8.11.1 → 8.11.2-rc.1

package/src/domain/JsonParameterStore.spec.ts

@@ -1,212 +0,0 @@
-import {prototypeOf, Store} from "@tsed/core";
-
-import {Allow} from "../decorators/common/allow.js";
-import {Required} from "../decorators/common/required.js";
-import {In} from "../decorators/operations/in.js";
-import {Path} from "../decorators/operations/path.js";
-import {Get} from "../decorators/operations/route.js";
-import {getJsonEntityStore} from "../utils/getJsonEntityStore.js";
-import {JsonClassStore} from "./JsonClassStore.js";
-import {JsonMethodStore} from "./JsonMethodStore.js";
-import {JsonParameterStore} from "./JsonParameterStore.js";
-import {JsonParameterTypes} from "./JsonParameterTypes.js";
-
-describe("JsonParameterStore", () => {
-  describe("new JsonParameterStore", () => {
-    it("should load entities", () => {
-      class TestDynamicUrlCtrl {
-        async get(id: string) {}
-      }
-
-      const entity = getJsonEntityStore(prototypeOf(TestDynamicUrlCtrl), "get", 0);
-
-      expect(entity).toBeInstanceOf(JsonParameterStore);
-      expect(entity.parent).toBeInstanceOf(JsonMethodStore);
-      expect(entity.parent.parent).toBeInstanceOf(JsonClassStore);
-      expect(entity.parent.parent.parent).toBeInstanceOf(JsonClassStore);
-      expect(entity.nestedGenerics).toEqual([]);
-      expect(entity.required).toBe(false);
-      expect(entity.isRequired("")).toBe(false);
-      expect(entity.allowedRequiredValues).toEqual([]);
-    });
-  });
-  describe("getParams()", () => {
-    it("should returns params (body + path)", () => {
-      // GIVEN
-      @Path("/")
-      class Test {
-        @Get("/")
-        test(@In("body") body: any) {}
-      }
-
-      // WHEN
-      const result = JsonParameterStore.getParams(prototypeOf(Test), "test");
-
-      // THEN
-      expect(result[0].parameter.get("in")).toEqual("body");
-    });
-    it("should returns params (body)", () => {
-      // GIVEN
-      class Test {
-        @Get("/")
-        test(@In(JsonParameterTypes.BODY) body: any) {}
-      }
-
-      // WHEN
-      const result = JsonParameterStore.getParams(prototypeOf(Test), "test");
-      // THEN
-
-      expect(result[0].parameter.get("in")).toEqual("body");
-    });
-    it("should returns params from inherited", () => {
-      // GIVEN
-      class BaseTest {
-        @Get("/")
-        list(@(In("query").Name("search")) search: string) {}
-
-        @Get("/")
-        base(@(In("query").Name("base")) test: string) {}
-      }
-
-      class Test extends BaseTest {
-        @Get("/")
-        test(@(In("query").Name("search")) search: string) {}
-
-        @Get("/")
-        base(@(In("query").Name("test")) search: string) {}
-      }
-
-      // WHEN
-      const result1 = JsonParameterStore.getParams(prototypeOf(Test), "list");
-      const result2 = JsonParameterStore.getParams(prototypeOf(Test), "test");
-      const result3 = JsonParameterStore.getParams(prototypeOf(Test), "unknown");
-      const result4 = JsonParameterStore.getParams(prototypeOf(Test), "base");
-
-      // THEN
-      expect(result1.length).toEqual(1);
-      expect(result2.length).toEqual(1);
-      expect(result3).toEqual([]);
-      expect(result4.length).toEqual(1);
-      expect(result4[0].token).toBe(Test);
-    });
-  });
-  describe("isRequired", () => {
-    describe("when property is required", () => {
-      it("should return the expected required state", () => {
-        class Test {
-          @Get("/")
-          test(@Required() @In(JsonParameterTypes.BODY) body: any) {}
-        }
-
-        const store = JsonParameterStore.get(Test, "test", 0);
-
-        expect(store.isRequired(0)).toEqual(false);
-        expect(store.isRequired("")).toEqual(true);
-        expect(store.isRequired(null)).toEqual(true);
-        expect(store.isRequired(undefined)).toEqual(true);
-      });
-    });
-
-    describe("when property is required and have allowed values", () => {
-      it("should validate the required values", () => {
-        class Test {
-          @Get("/")
-          test(@Required() @Allow(null) @In(JsonParameterTypes.BODY) body: any) {}
-        }
-
-        const store = JsonParameterStore.get(Test, "test", 0);
-
-        expect(store.allowedRequiredValues).toEqual([null]);
-        expect(store.isRequired(0)).toEqual(false);
-        expect(store.isRequired("")).toEqual(true);
-        expect(store.isRequired(null)).toEqual(false);
-        expect(store.isRequired(undefined)).toEqual(true);
-      });
-
-      it("should validate the required values (2)", () => {
-        class Test {
-          @Get("/")
-          test(@Required() @Allow("") @In(JsonParameterTypes.BODY) body: any) {}
-        }
-
-        const store = JsonParameterStore.get(Test, "test", 0);
-        store.required = true;
-
-        expect(store.allowedRequiredValues).toEqual([""]);
-        expect(store.isRequired(0)).toEqual(false);
-        expect(store.isRequired("")).toEqual(false);
-        expect(store.isRequired(null)).toEqual(true);
-        expect(store.isRequired(undefined)).toEqual(true);
-      });
-
-      it("should validate the required values (3)", () => {
-        class Test {
-          @Get("/")
-          test(@Required() @Allow("") @In(JsonParameterTypes.BODY) body: any) {}
-        }
-
-        const store = JsonParameterStore.get(Test, "test", 0);
-        store.required = true;
-
-        expect(store.allowedRequiredValues).toEqual([""]);
-        expect(store.isRequired(0)).toEqual(false);
-        expect(store.isRequired("")).toEqual(false);
-        expect(store.isRequired(null)).toEqual(true);
-        expect(store.isRequired(undefined)).toEqual(true);
-      });
-    });
-
-    describe("when property is not required", () => {
-      it("should validate values", () => {
-        class Test {
-          @Get("/")
-          test(@Required(false) @Allow("") @In(JsonParameterTypes.BODY) body: any) {}
-        }
-
-        const store = JsonParameterStore.get(Test, "test", 0);
-        store.required = false;
-
-        expect(store.isRequired(0)).toEqual(false);
-        expect(store.isRequired("")).toEqual(false);
-        expect(store.isRequired(null)).toEqual(false);
-        expect(store.isRequired(undefined)).toEqual(false);
-      });
-    });
-  });
-  describe("props", () => {
-    it("should return the required value", () => {
-      class Test {
-        method(arg1: any, arg2: any) {}
-      }
-
-      const paramMetadata = JsonParameterStore.get(Test, "method", 0);
-      paramMetadata.required = true;
-      paramMetadata.expression = "test";
-      paramMetadata.type = Test;
-
-      expect(paramMetadata.required).toEqual(true);
-
-      expect(paramMetadata.expression).toEqual("test");
-
-      expect(paramMetadata.collectionType).toEqual(undefined);
-      expect(paramMetadata.type).toEqual(Test);
-      expect(paramMetadata.index).toEqual(0);
-      expect(paramMetadata.store).toBeInstanceOf(Store);
-    });
-  });
-  describe("as a service", () => {
-    it("should return the service", () => {
-      class Test {
-        method(arg1: any, arg2: any) {}
-      }
-
-      const paramMetadata = JsonParameterStore.get(Test, "method", 0);
-      paramMetadata.required = true;
-      paramMetadata.expression = "test";
-      paramMetadata.type = Test;
-      paramMetadata.paramType = "ERR";
-
-      expect(paramMetadata.paramType).toEqual("ERR");
-    });
-  });
-});

package/src/domain/JsonParameterStore.ts

@@ -1,129 +0,0 @@
-import {ancestorsOf, DecoratorTypes, isClass, isMethodDescriptor, Metadata, prototypeOf, Type} from "@tsed/core";
-
-import {JsonEntityComponent} from "../decorators/config/jsonEntityComponent.js";
-import {JsonEntityStore, JsonEntityStoreOptions} from "./JsonEntityStore.js";
-import type {JsonMethodStore} from "./JsonMethodStore.js";
-import {JsonParameter} from "./JsonParameter.js";
-
-export interface JsonParameterStoreOptions extends JsonEntityStoreOptions {
-  dataPath?: string;
-  paramType?: string;
-  expression?: string;
-}
-
-export interface PipeMethods<T = any, R = any> {
-  transform(value: T, metadata: JsonParameterStore): R;
-}
-
-@JsonEntityComponent(DecoratorTypes.PARAM)
-export class JsonParameterStore extends JsonEntityStore {
-  public paramType: string;
-  public expression: string;
-  public dataPath: string;
-  /**
-   * Define pipes can be called by the framework to transform input parameter
-   */
-  public pipes: Type<PipeMethods>[];
-  /**
-   * Ref to JsonParameter when the decorated object is a parameter.
-   */
-  readonly parameter: JsonParameter = new JsonParameter();
-  readonly parent: JsonMethodStore = JsonEntityStore.fromMethod(this.target, this.propertyKey);
-
-  constructor(options: JsonParameterStoreOptions) {
-    super(options);
-    this.pipes = options.pipes || [];
-    this.paramType = options.paramType || this.paramType;
-    this.expression = options.expression || this.expression;
-    this.dataPath = options.dataPath || this.dataPath;
-  }
-
-  get nestedGenerics(): Type<any>[][] {
-    return this.parameter.nestedGenerics;
-  }
-
-  set nestedGenerics(nestedGenerics: Type<any>[][]) {
-    this.parameter.nestedGenerics = nestedGenerics;
-  }
-
-  /**
-   * Return the required state.
-   * @returns {boolean}
-   */
-  get required(): boolean {
-    return !!this.parameter.get("required");
-  }
-
-  set required(value: boolean) {
-    this.parameter.required(value);
-  }
-
-  get allowedRequiredValues() {
-    return this.schema.$allow;
-  }
-
-  get schema() {
-    return this.parameter.$schema;
-  }
-
-  static getParams<T extends JsonParameterStore = JsonParameterStore>(target: Type<any>, propertyKey: string | symbol): T[] {
-    const params: T[] = [];
-
-    const klass = ancestorsOf(target)
-      .reverse()
-      .find((target) => {
-        return isMethodDescriptor(target, propertyKey) && JsonEntityStore.fromMethod(target, propertyKey).children.size;
-      });
-
-    if (klass) {
-      JsonEntityStore.fromMethod(klass, propertyKey).children.forEach((param: T, index) => {
-        params[+index] = param;
-      });
-
-      return params;
-    }
-
-    return [];
-  }
-
-  static get(target: Type<any>, propertyKey: string | symbol, index: number) {
-    return JsonEntityStore.from<JsonParameterStore>(prototypeOf(target), propertyKey, index);
-  }
-
-  /**
-   * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
-   * @param value
-   * @returns {boolean}
-   */
-  isRequired(value: any): boolean {
-    return this.required && [undefined, null, ""].includes(value) && !this.allowedRequiredValues.includes(value);
-  }
-
-  protected build() {
-    if (!this._type) {
-      const type: any = Metadata.getParamTypes(prototypeOf(this.target), this.propertyKey)[this.index!];
-
-      this.buildType(type);
-    }
-
-    this._type = this._type || Object;
-    this.parent.children.set(this.index!, this);
-    this.parent.operation.addParameter(this.index as number, this.parameter);
-
-    if (this.collectionType) {
-      this.parameter.schema().type(this.collectionType);
-    }
-
-    if (isClass(this._type)) {
-      this.parameter.itemSchema(JsonEntityStore.from(this._type).schema);
-    } else {
-      this.parameter.itemSchema().type(this._type);
-    }
-  }
-}
-
-/**
- * @alias JsonParameterStore
- */
-export type ParamMetadata = JsonParameterStore;
-export const ParamMetadata = JsonParameterStore;

package/src/domain/JsonParameterTypes.spec.ts

@@ -1,12 +0,0 @@
-import {isParameterType} from "../index.js";
-
-describe("JsonParameterType", () => {
-  describe("isParameterType", () => {
-    it("should return true", () => {
-      expect(isParameterType("query")).toBe(true);
-    });
-    it("should return false", () => {
-      expect(isParameterType("req")).toBe(false);
-    });
-  });
-});

package/src/domain/JsonParameterTypes.ts

@@ -1,20 +0,0 @@
-export enum JsonParameterTypes {
-  BODY = "body",
-  PATH = "path",
-  QUERY = "query",
-  HEADER = "header",
-  COOKIES = "cookie",
-  FILES = "files"
-}
-/**
- * @ignore
- */
-export function formatParameterType(type: any): any {
-  return String(type).toLowerCase().replace("raw_", "").replace("cookies", "cookie");
-}
-/**
- * @ignore
- */
-export function isParameterType(type: string) {
-  return Object.values(JsonParameterTypes).includes(formatParameterType(type) as any);
-}

package/src/domain/JsonPropertyStore.spec.ts

@@ -1,177 +0,0 @@
-import {prototypeOf} from "@tsed/core";
-
-import {Allow, JsonClassStore, JsonPropertyStore, Required} from "../index.js";
-import {getJsonEntityStore} from "../utils/getJsonEntityStore.js";
-
-describe("JsonParameterStore", () => {
-  it("should create entity with required value", () => {
-    class TestDynamicUrlCtrl {
-      @Required()
-      prop: string;
-    }
-
-    const entity = getJsonEntityStore(prototypeOf(TestDynamicUrlCtrl), "prop");
-
-    expect(entity).toBeInstanceOf(JsonPropertyStore);
-    expect(entity.parent).toBeInstanceOf(JsonClassStore);
-    expect(entity.parent.parent.parent).toBeInstanceOf(JsonClassStore);
-    expect(entity.nestedGenerics).toEqual([]);
-    expect(entity.required).toBe(true);
-    expect(entity.isRequired("")).toBe(true);
-    expect(entity.allowedRequiredValues).toEqual([]);
-    expect(entity.isDiscriminatorKey()).toEqual(false);
-
-    entity.required = false;
-    expect(entity.required).toBe(false);
-
-    entity.required = true;
-    expect(entity.required).toBe(true);
-  });
-  it("should create entity with allowed value", () => {
-    class TestDynamicUrlCtrl {
-      @Required(true, "")
-      prop: string;
-    }
-
-    const entity = getJsonEntityStore(prototypeOf(TestDynamicUrlCtrl), "prop");
-
-    expect(entity).toBeInstanceOf(JsonPropertyStore);
-    expect(entity.parent).toBeInstanceOf(JsonClassStore);
-    expect(entity.parent.parent.parent).toBeInstanceOf(JsonClassStore);
-    expect(entity.nestedGenerics).toEqual([]);
-    expect(entity.required).toBe(true);
-    expect(entity.isRequired("")).toBe(false);
-    expect(entity.allowedRequiredValues).toEqual([""]);
-
-    entity.required = false;
-    expect(entity.required).toBe(false);
-
-    entity.required = true;
-    expect(entity.required).toBe(true);
-  });
-  describe("required() and allowRequiredValues", () => {
-    it("should return the required value", () => {
-      class Test {
-        @Required(true)
-        @Allow(null, "")
-        test: string;
-      }
-
-      const jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-      jsonPropertyStore.required = true;
-      jsonPropertyStore.type = Test;
-
-      expect(jsonPropertyStore.required).toEqual(true);
-
-      expect(jsonPropertyStore.collectionType).toEqual(undefined);
-      expect(jsonPropertyStore.type).toEqual(Test);
-      expect(jsonPropertyStore.isCollection).toEqual(false);
-    });
-  });
-
-  describe("isRequired", () => {
-    describe("when property is required", () => {
-      class Test {
-        @Required(true)
-        test: string;
-      }
-
-      let jsonPropertyStore: JsonPropertyStore;
-
-      beforeAll(() => {
-        jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-        jsonPropertyStore.required = true;
-      });
-      it("should return false (value 0)", () => {
-        expect(jsonPropertyStore.isRequired(0)).toEqual(false);
-      });
-
-      it("should return true (value '')", () => {
-        expect(jsonPropertyStore.isRequired("")).toEqual(true);
-      });
-      it("should return true (value null)", () => {
-        expect(jsonPropertyStore.isRequired(null)).toEqual(true);
-      });
-      it("should return true (value undefined)", () => {
-        expect(jsonPropertyStore.isRequired(undefined)).toEqual(true);
-      });
-    });
-
-    describe("when property is required and have allowed values", () => {
-      it("should validate the required values", () => {
-        class Test {
-          @Required()
-          @Allow(null)
-          test: string;
-        }
-
-        let jsonPropertyStore: JsonPropertyStore;
-        jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-
-        expect(jsonPropertyStore.allowedRequiredValues).toEqual([null]);
-        expect(jsonPropertyStore.isRequired(0)).toEqual(false);
-        expect(jsonPropertyStore.isRequired("")).toEqual(true);
-        expect(jsonPropertyStore.isRequired(null)).toEqual(false);
-        expect(jsonPropertyStore.isRequired(undefined)).toEqual(true);
-      });
-
-      it("should validate the required values (2)", () => {
-        class Test {
-          @Allow("")
-          test: string;
-        }
-
-        let jsonPropertyStore: JsonPropertyStore;
-        jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-
-        expect(jsonPropertyStore.allowedRequiredValues).toEqual([""]);
-        expect(jsonPropertyStore.isRequired(0)).toEqual(false);
-        expect(jsonPropertyStore.isRequired("")).toEqual(false);
-        expect(jsonPropertyStore.isRequired(null)).toEqual(true);
-        expect(jsonPropertyStore.isRequired(undefined)).toEqual(true);
-      });
-
-      it("should validate the required values (3)", () => {
-        class Test {
-          @Allow("")
-          test: string;
-        }
-
-        let jsonPropertyStore: JsonPropertyStore;
-        jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-
-        expect(jsonPropertyStore.allowedRequiredValues).toEqual([""]);
-        expect(jsonPropertyStore.isRequired(0)).toEqual(false);
-        expect(jsonPropertyStore.isRequired("")).toEqual(false);
-        expect(jsonPropertyStore.isRequired(null)).toEqual(true);
-        expect(jsonPropertyStore.isRequired(undefined)).toEqual(true);
-      });
-    });
-
-    describe("when property is not required", () => {
-      it("should validate values", () => {
-        class Test {
-          @Required(false)
-          test: string;
-        }
-
-        const jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-        jsonPropertyStore.required = false;
-        expect(jsonPropertyStore.isRequired(0)).toEqual(false);
-        expect(jsonPropertyStore.isRequired("")).toEqual(false);
-        expect(jsonPropertyStore.isRequired(null)).toEqual(false);
-        expect(jsonPropertyStore.isRequired(undefined)).toEqual(false);
-      });
-    });
-  });
-  describe("get()", () => {
-    class Test {
-      test: string;
-    }
-
-    it("should return the jsonPropertyStore", () => {
-      const jsonPropertyStore = JsonPropertyStore.get(Test, "test");
-      expect(jsonPropertyStore).toBeInstanceOf(JsonPropertyStore);
-    });
-  });
-});

package/src/domain/JsonPropertyStore.ts

@@ -1,92 +0,0 @@
-import {DecoratorTypes, Metadata, prototypeOf, Type} from "@tsed/core";
-
-import {JsonEntityComponent} from "../decorators/config/jsonEntityComponent.js";
-import type {JsonClassStore} from "./JsonClassStore.js";
-import {JsonEntityStore} from "./JsonEntityStore.js";
-import {JsonSchema} from "./JsonSchema.js";
-
-@JsonEntityComponent(DecoratorTypes.PROP)
-export class JsonPropertyStore extends JsonEntityStore {
-  readonly parent: JsonClassStore = JsonEntityStore.from(this.target);
-
-  /**
-   * Return the required state.
-   * @returns {boolean}
-   */
-  get required(): boolean {
-    return this.parent.schema.isRequired(this.propertyKey as string);
-  }
-
-  /**
-   * Change the state of the required data.
-   * @param value
-   */
-  set required(value: boolean) {
-    if (value) {
-      this.parent.schema.addRequired(this.propertyKey as string);
-    } else {
-      this.parent.schema.removeRequired(this.propertyKey as string);
-    }
-  }
-
-  get allowedRequiredValues() {
-    return this.schema.$allow;
-  }
-
-  discriminatorKey() {
-    this.parent.schema.discriminatorKey(String(this.propertyKey));
-    this.itemSchema.isDiscriminatorKey = true;
-    return this;
-  }
-
-  isDiscriminatorKey() {
-    return this.itemSchema.isDiscriminatorKey;
-  }
-
-  /**
-   * Check precondition between value, required and allowedRequiredValues to know if the entity is required.
-   * @param value
-   * @returns {boolean}
-   */
-  isRequired(value: any): boolean {
-    return this.required && [undefined, null, ""].includes(value) && !this.allowedRequiredValues.includes(value);
-  }
-
-  protected build() {
-    if (!this._type) {
-      this.buildType(Metadata.getType(prototypeOf(this.target), this.propertyKey));
-    }
-
-    this._type = this._type || Object;
-
-    const properties = this.parent.schema.get("properties");
-
-    let schema: JsonSchema = properties[this.propertyName];
-
-    if (!schema) {
-      this.parent.children.set(this.propertyName, this);
-
-      schema = JsonSchema.from({
-        type: this.collectionType || this.type
-      });
-
-      if (this.collectionType) {
-        schema.itemSchema(this.type);
-      }
-    }
-
-    this.parent.schema.addProperty(this.propertyName, schema);
-
-    this._schema = schema;
-  }
-
-  static get(target: Type<any>, propertyKey: string | symbol) {
-    return JsonEntityStore.from<JsonPropertyStore>(prototypeOf(target), propertyKey);
-  }
-}
-
-/**
- * @alias JsonPropertyStore
- */
-export type PropertyMetadata = JsonPropertyStore;
-export const PropertyMetadata = JsonPropertyStore;

package/src/domain/JsonRequestBody.ts

@@ -1,47 +0,0 @@
-import {OpenSpecHash, OS3MediaType, OS3RequestBody} from "@tsed/openspec";
-
-import {toJsonMapCollection} from "../utils/toJsonMapCollection.js";
-import {JsonMap} from "./JsonMap.js";
-import {JsonSchema} from "./JsonSchema.js";
-
-export type JsonRequestBodyOptions = OS3RequestBody<JsonSchema>;
-
-export class JsonRequestBody extends JsonMap<JsonRequestBodyOptions> {
-  $kind = "operationRequestBody";
-
-  constructor(obj: Partial<JsonRequestBodyOptions> = {}) {
-    super(obj);
-
-    this.content(obj.content || ({} as any));
-  }
-
-  description(description: string): this {
-    this.set("description", description);
-
-    return this;
-  }
-
-  content(content: OpenSpecHash<OS3MediaType<JsonSchema>>) {
-    this.set("content", toJsonMapCollection(content));
-
-    return this;
-  }
-
-  addContent(mediaType: string, schema: JsonSchema, examples?: any) {
-    const content = this.get("content");
-    const mediaContent = new JsonMap();
-
-    mediaContent.set("schema", schema);
-    examples && mediaContent.set("examples", examples);
-
-    content.set(mediaType, mediaContent);
-
-    return this;
-  }
-
-  required(required: boolean): this {
-    this.set("required", required);
-
-    return this;
-  }
-}