@tsed/schema 8.0.1 → 8.0.3

package/src/domain/JsonEntityStore.spec.ts

@@ -0,0 +1,277 @@
+import {
+  Allow,
+  In,
+  JsonEntityStore,
+  JsonMethodStore,
+  JsonOperation,
+  JsonParameter,
+  JsonParameterStore,
+  JsonPropertyStore,
+  Property,
+  Required
+} from "../index.js";
+
+describe("JsonEntityStore", () => {
+  it("should create JsonEntityStore", () => {
+    class Model {
+      @Property()
+      id: string;
+
+      method(@In("path") param: string) {}
+    }
+
+    // CLASS
+    const storeClass = JsonEntityStore.from(Model);
+
+    expect(storeClass).toBeInstanceOf(JsonEntityStore);
+    expect(storeClass.decoratorType).toBe("class");
+    expect(storeClass.propertyName).toBe("undefined");
+    expect(storeClass.propertyKey).toBeUndefined();
+    expect(storeClass.index).toBeUndefined();
+    expect(storeClass.parent).toBe(storeClass);
+    expect(storeClass.type).toEqual(Model);
+    expect(storeClass.target).toEqual(Model);
+    expect(storeClass.token).toEqual(Model);
+    expect(storeClass.isCollection).toBe(false);
+    expect(storeClass.isDate).toBe(false);
+    expect(storeClass.isPrimitive).toBe(false);
+    expect(storeClass.isObject).toBe(false);
+    expect(storeClass.isClass).toBe(true);
+    expect(storeClass.isDiscriminatorChild).toBe(false);
+    expect(storeClass.getBestType()).toBe(Model);
+
+    // PROPERTY
+    const storeProp = JsonEntityStore.from(Model).children.get("id") as JsonPropertyStore;
+    expect(storeProp).toBeInstanceOf(JsonEntityStore);
+    expect(storeProp.decoratorType).toBe("property");
+    expect(storeProp.propertyKey).toBe("id");
+    expect(storeProp.propertyName).toBe("id");
+    expect(storeProp.index).toBeUndefined();
+    expect(storeProp.nestedGenerics).toEqual([]);
+    expect(storeProp.parent).toEqual(storeClass);
+    expect(storeProp.type).toEqual(String);
+    expect(storeProp.target).toEqual(Model);
+    expect(storeProp.token).toEqual(Model);
+    expect(storeProp.isCollection).toBe(false);
+    expect(storeProp.isDate).toBe(false);
+    expect(storeProp.isPrimitive).toBe(true);
+    expect(storeProp.isObject).toBe(false);
+    expect(storeProp.isClass).toBe(false);
+    expect(storeProp.isGetterOnly()).toBeFalsy();
+
+    // METHOD
+    const storeMethod = JsonEntityStore.from(Model).children.get("method") as JsonMethodStore;
+    expect(storeMethod).toBeInstanceOf(JsonEntityStore);
+    expect(storeMethod.propertyKey).toBe("method");
+    expect(storeMethod.propertyName).toBe("method");
+    expect(storeMethod.decoratorType).toBe("method");
+    expect(storeMethod.index).toBeUndefined();
+    expect(storeMethod.operation).toBeInstanceOf(JsonOperation);
+    expect(storeMethod.nestedGenerics).toEqual([]);
+    expect(storeMethod.parent).toEqual(storeClass);
+    expect(storeMethod.target).toEqual(Model);
+    expect(storeMethod.type).toEqual(Object);
+    expect(storeMethod.target).toEqual(Model);
+    expect(storeMethod.token).toEqual(Model);
+    expect(storeMethod.isCollection).toBe(false);
+    expect(storeMethod.isDate).toBe(false);
+    expect(storeMethod.isPrimitive).toBe(false);
+    expect(storeMethod.isObject).toBe(false);
+    expect(storeMethod.isClass).toBe(false);
+
+    // PARAMETERS
+    const storeParam = JsonEntityStore.from(Model).children.get("method")?.children.get(0) as JsonParameterStore;
+    expect(storeParam).toBeInstanceOf(JsonEntityStore);
+    expect(storeParam.propertyKey).toBe("method");
+    expect(storeParam.propertyName).toBe("method");
+    expect(storeParam.index).toBe(0);
+    expect(storeParam.decoratorType).toBe("parameter");
+    expect(storeParam.parameter).toBeInstanceOf(JsonParameter);
+    expect(storeParam.nestedGenerics).toEqual([]);
+    expect(storeParam.parent).toEqual(storeMethod);
+    expect(storeParam.type).toEqual(String);
+    expect(storeParam.target).toEqual(Model);
+    expect(storeParam.token).toEqual(Model);
+    expect(storeParam.isCollection).toBe(false);
+    expect(storeParam.isDate).toBe(false);
+    expect(storeParam.isPrimitive).toBe(true);
+    expect(storeParam.isObject).toBe(false);
+    expect(storeParam.isClass).toBe(false);
+    expect(storeParam.isGetterOnly()).toBe(false);
+    expect(storeParam.toString()).toBe("Model:method:0");
+  });
+  it("should manage enum from babel", () => {
+    enum MyEnum {
+      test = "test"
+    }
+
+    class Model {
+      test: MyEnum;
+    }
+
+    Reflect.defineMetadata("design:type", MyEnum, Model.prototype, "test");
+
+    // CLASS
+    Property()(Model.prototype, "test");
+    const store = JsonEntityStore.from(Model, "test");
+
+    expect(store.type).toEqual(String);
+  });
+
+  describe("isGetterOnly()", () => {
+    it("should create JsonEntityStore on getter", () => {
+      class Model {
+        @Property()
+        get id() {
+          return "id";
+        }
+      }
+
+      // CLASS
+      // PROPERTY
+      const storeProp = JsonEntityStore.from(Model).children.get("id") as JsonPropertyStore;
+      expect(storeProp.isGetterOnly()).toBeTruthy();
+    });
+    it("should create JsonEntityStore on getter/setter", () => {
+      class Model {
+        @Property()
+        get id() {
+          return "id";
+        }
+        set id(id: string) {}
+      }
+
+      // CLASS
+      // PROPERTY
+      const storeProp = JsonEntityStore.from(Model).children.get("id") as JsonPropertyStore;
+      expect(storeProp.isGetterOnly()).toBeFalsy();
+    });
+  });
+
+  describe("required() and allowRequiredValues", () => {
+    it("should return the required value", () => {
+      class Test {
+        @Required(true)
+        @Allow(null, "")
+        test: string;
+      }
+
+      const propertyMetadata = JsonEntityStore.get(Test, "test");
+      propertyMetadata.required = true;
+      propertyMetadata.type = Test;
+
+      expect(propertyMetadata.required).toEqual(true);
+
+      expect(propertyMetadata.collectionType).toEqual(undefined);
+      expect(propertyMetadata.type).toEqual(Test);
+      expect(propertyMetadata.isCollection).toEqual(false);
+    });
+  });
+
+  describe("isRequired", () => {
+    describe("when property is required", () => {
+      class Test {
+        @Required(true)
+        test: string;
+      }
+
+      let propertyMetadata: JsonEntityStore;
+
+      beforeAll(() => {
+        propertyMetadata = JsonEntityStore.get(Test, "test");
+        propertyMetadata.required = true;
+      });
+      it("should return false (value 0)", () => {
+        expect(propertyMetadata.isRequired(0)).toEqual(false);
+      });
+
+      it("should return true (value '')", () => {
+        expect(propertyMetadata.isRequired("")).toEqual(true);
+      });
+      it("should return true (value null)", () => {
+        expect(propertyMetadata.isRequired(null)).toEqual(true);
+      });
+      it("should return true (value undefined)", () => {
+        expect(propertyMetadata.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 propertyMetadata: JsonEntityStore;
+        propertyMetadata = JsonEntityStore.get(Test, "test");
+
+        expect(propertyMetadata.allowedRequiredValues).toEqual([null]);
+        expect(propertyMetadata.isRequired(0)).toEqual(false);
+        expect(propertyMetadata.isRequired("")).toEqual(true);
+        expect(propertyMetadata.isRequired(null)).toEqual(false);
+        expect(propertyMetadata.isRequired(undefined)).toEqual(true);
+      });
+
+      it("should validate the required values (2)", () => {
+        class Test {
+          @Allow("")
+          test: string;
+        }
+
+        let propertyMetadata: JsonEntityStore;
+        propertyMetadata = JsonEntityStore.get(Test, "test");
+
+        expect(propertyMetadata.allowedRequiredValues).toEqual([""]);
+        expect(propertyMetadata.isRequired(0)).toEqual(false);
+        expect(propertyMetadata.isRequired("")).toEqual(false);
+        expect(propertyMetadata.isRequired(null)).toEqual(true);
+        expect(propertyMetadata.isRequired(undefined)).toEqual(true);
+      });
+
+      it("should validate the required values (3)", () => {
+        class Test {
+          @Allow("")
+          test: string;
+        }
+
+        let propertyMetadata: JsonEntityStore;
+        propertyMetadata = JsonEntityStore.get(Test, "test");
+
+        expect(propertyMetadata.allowedRequiredValues).toEqual([""]);
+        expect(propertyMetadata.isRequired(0)).toEqual(false);
+        expect(propertyMetadata.isRequired("")).toEqual(false);
+        expect(propertyMetadata.isRequired(null)).toEqual(true);
+        expect(propertyMetadata.isRequired(undefined)).toEqual(true);
+      });
+    });
+
+    describe("when property is not required", () => {
+      it("should validate values", () => {
+        class Test {
+          @Required(false)
+          test: string;
+        }
+
+        const propertyMetadata = JsonEntityStore.get(Test, "test");
+        propertyMetadata.required = false;
+        expect(propertyMetadata.isRequired(0)).toEqual(false);
+        expect(propertyMetadata.isRequired("")).toEqual(false);
+        expect(propertyMetadata.isRequired(null)).toEqual(false);
+        expect(propertyMetadata.isRequired(undefined)).toEqual(false);
+      });
+    });
+  });
+
+  describe("get()", () => {
+    class Test {
+      test: string;
+    }
+
+    it("should return the propertyMetadata", () => {
+      const propertyMetadata = JsonEntityStore.get(Test, "test");
+      expect(propertyMetadata).toBeInstanceOf(JsonEntityStore);
+    });
+  });
+});

package/src/domain/JsonEntityStore.ts

@@ -0,0 +1,284 @@
+import {
+  ancestorsOf,
+  classOf,
+  decoratorTypeOf,
+  DecoratorTypes,
+  descriptorOf,
+  isArrayOrArrayClass,
+  isArrowFn,
+  isClass,
+  isClassObject,
+  isCollection,
+  isDate,
+  isObject,
+  isPlainObject,
+  isPrimitiveOrPrimitiveClass,
+  nameOf,
+  prototypeOf,
+  Store,
+  Type
+} from "@tsed/core";
+
+import type {JsonClassStore} from "./JsonClassStore.js";
+import type {JsonMethodStore} from "./JsonMethodStore.js";
+import type {JsonParameterStore} from "./JsonParameterStore.js";
+import type {JsonPropertyStore} from "./JsonPropertyStore.js";
+import type {JsonSchema} from "./JsonSchema.js";
+
+/**
+ * @ignore
+ */
+export const JsonEntitiesContainer = new Map<DecoratorTypes, Type<JsonEntityStore>>();
+
+export interface JsonEntityStoreOptions {
+  decoratorType: DecoratorTypes;
+  target: Type<any>;
+  propertyKey?: string | symbol;
+  index?: number;
+  descriptor?: any;
+  type?: Type<any>;
+  collectionType?: Type<any>;
+  beforeMiddlewares?: Function[];
+  middlewares?: Function[];
+  afterMiddlewares?: Function[];
+
+  [key: string]: any;
+}
+
+export abstract class JsonEntityStore implements JsonEntityStoreOptions {
+  /**
+   * Original property key decorated by the decorator
+   */
+  readonly propertyKey: string | symbol;
+  /**
+   * Alias of the property
+   */
+  readonly propertyName: string;
+  /**
+   * Parameter index
+   */
+  readonly index: number;
+  /**
+   * Method's descriptor
+   */
+  readonly descriptor: PropertyDescriptor;
+  /**
+   * Decorator type used to declare the JsonSchemaStore.
+   */
+  readonly decoratorType: DecoratorTypes;
+  /**
+   * Type of the collection (Array, Map, Set, etc...)
+   */
+  public collectionType: Type<any>;
+  public token: Type<any>;
+  readonly store: Store;
+  readonly isStore = true;
+  readonly parent: JsonEntityStore;
+  readonly target: Type<any>;
+  /**
+   *
+   */
+  protected _type: Type<any>;
+  /**
+   * Ref to JsonSchema
+   */
+  protected _schema: JsonSchema;
+
+  [key: string]: any;
+
+  constructor(options: JsonEntityStoreOptions) {
+    const {target, propertyKey, descriptor, index, decoratorType} = options;
+    this.target = target;
+    this.propertyKey = propertyKey!;
+    this.propertyName = String(propertyKey);
+    this.descriptor = descriptor;
+    this.index = index!;
+    this.decoratorType = decoratorType;
+    this.token = target;
+    this.store = options.store;
+    this.parent = this;
+  }
+
+  /**
+   * Return the class name of the entity.
+   * @returns {string}
+   */
+  get targetName(): string {
+    return nameOf(this.token);
+  }
+
+  get isCollection(): boolean {
+    return !!this.collectionType;
+  }
+
+  get isArray() {
+    return isArrayOrArrayClass(this.collectionType);
+  }
+
+  get discriminatorAncestor(): JsonEntityStore | undefined {
+    const ancestors = ancestorsOf(this.target);
+    const ancestor = ancestors.find((ancestor) => JsonEntityStore.from(ancestor).schema.isDiscriminator);
+    return ancestor && JsonEntityStore.from(ancestor);
+  }
+
+  get isPrimitive() {
+    return isPrimitiveOrPrimitiveClass(this._type);
+  }
+
+  get isDate() {
+    return isDate(this.computedType);
+  }
+
+  get isObject() {
+    return isObject(this.computedType);
+  }
+
+  get isClass() {
+    return isClass(this.computedType);
+  }
+
+  /**
+   * Return the JsonSchema
+   */
+  get schema(): JsonSchema {
+    return this._schema;
+  }
+
+  get nestedGenerics(): Type<any>[][] {
+    return this.schema.nestedGenerics;
+  }
+
+  set nestedGenerics(nestedGenerics: Type<any>[][]) {
+    this.schema.nestedGenerics = nestedGenerics;
+  }
+
+  get type(): Type<any> | any {
+    return this._type;
+  }
+
+  /**
+   * Get original type without transformation
+   * @param value
+   */
+  set type(value: Type<any> | any) {
+    this._type = value;
+    this.build();
+  }
+
+  /**
+   * Return the itemSchema computed type. if the type is a function used for recursive model, the function will be called to
+   * get the right type.
+   */
+  get computedType() {
+    return this.itemSchema.getComputedType();
+  }
+
+  get itemSchema(): JsonSchema {
+    return this.isCollection ? this.schema.itemSchema() : this.schema;
+  }
+
+  get parentSchema(): JsonSchema {
+    return this.parent.schema;
+  }
+
+  get isDiscriminatorChild() {
+    return this.schema.isDiscriminator && this.discriminatorAncestor?.schema.discriminator().base !== this.target;
+  }
+
+  static from<T extends JsonClassStore = JsonClassStore>(target: Type<any>): T;
+
+  static from<T extends JsonPropertyStore = JsonPropertyStore>(target: Type<any> | any, propertyKey: string | symbol): T;
+
+  static from<T extends JsonParameterStore = JsonParameterStore>(target: Type<any> | any, propertyKey: string | symbol, index: number): T;
+
+  static from<T extends JsonMethodStore = JsonMethodStore>(
+    target: Type<any> | any,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor
+  ): T;
+
+  static from<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T;
+
+  static from<T extends JsonEntityStore = JsonEntityStore>(...args: any[]): T {
+    if (args[0].isStore) {
+      return args[0] as T;
+    }
+
+    const target = args[0];
+
+    if (args.length > 1) {
+      args[0] = prototypeOf(args[0]);
+    }
+
+    const store = Store.from(...args);
+
+    if (!store.has("JsonEntityStore")) {
+      const decoratorType = decoratorTypeOf(args);
+      const entityStore = JsonEntitiesContainer.get(decoratorType)!;
+
+      const jsonSchemaStore = new entityStore({
+        store,
+        decoratorType,
+        target: classOf(target),
+        propertyKey: args[1],
+        index: typeof args[2] === "number" ? args[2] : undefined,
+        descriptor: typeof args[2] === "object" ? args[2] : undefined
+      });
+
+      jsonSchemaStore.build();
+
+      store.set("JsonEntityStore", jsonSchemaStore);
+    }
+
+    return store.get<T>("JsonEntityStore")!;
+  }
+
+  static fromMethod<T extends JsonMethodStore = JsonMethodStore>(target: any, propertyKey: string | symbol) {
+    return this.from<T>(target, propertyKey, descriptorOf(target, propertyKey));
+  }
+
+  static get(target: Type<any>, propertyKey: string | symbol, descriptor?: any) {
+    return JsonEntityStore.from(prototypeOf(target), propertyKey, descriptor);
+  }
+
+  isGetterOnly() {
+    return isObject(this.descriptor) && !this.descriptor.value && this.descriptor.get && !this.descriptor.set;
+  }
+
+  get<T = any>(key: string, defaultValue?: any) {
+    return this.store.get<T>(key, defaultValue);
+  }
+
+  set(key: string, value?: any) {
+    return this.store.set(key, value);
+  }
+
+  toString() {
+    return [this.targetName, this.propertyName, this.index].filter((o) => o !== undefined).join(":");
+  }
+
+  protected abstract build(): void;
+
+  protected buildType(type: any) {
+    if (isCollection(type)) {
+      this.collectionType = type;
+    } else {
+      this._type = type;
+
+      // issue #1534: Enum metadata stored as plain object instead of String (see: https://github.com/tsedio/tsed/issues/1534)
+      if (this._type && isPlainObject(this._type)) {
+        this._type = String;
+      }
+    }
+  }
+
+  getBestType() {
+    return this.itemSchema.hasDiscriminator
+      ? this.itemSchema.discriminator().base
+      : isClassObject(this.type)
+        ? this.itemSchema.getTarget()
+        : isArrowFn(this.type)
+          ? this.type()
+          : this.type;
+  }
+}

package/src/domain/JsonFormatTypes.ts

@@ -0,0 +1,17 @@
+export enum JsonFormatTypes {
+  DATE_TIME = "date-time",
+  DATE = "date",
+  TIME = "time",
+  EMAIL = "email",
+  HOSTNAME = "hostname",
+  IPV4 = "ipv4",
+  IPV6 = "ipv6",
+  URI = "uri",
+  URL = "url",
+  URI_REF = "uri-reference",
+  URI_TEMPLATE = "uri-template",
+  JSON_POINTER = "json-pointer",
+  RELATIVE_JSON_POINTER = "relative-json-pointer",
+  UUID = "uuid",
+  REGEX = "regex"
+}

package/src/domain/JsonLazyRef.ts

@@ -0,0 +1,21 @@
+import {nameOf, Type} from "@tsed/core";
+
+import {getJsonEntityStore} from "../utils/getJsonEntityStore.js";
+
+export class JsonLazyRef {
+  readonly isLazyRef = true;
+
+  constructor(readonly getType: () => Type<any>) {}
+
+  get target() {
+    return this.getType();
+  }
+
+  get schema() {
+    return getJsonEntityStore(this.getType()).schema;
+  }
+
+  get name() {
+    return nameOf(this.getType());
+  }
+}

package/src/domain/JsonMap.spec.ts

@@ -0,0 +1,15 @@
+import "../index.js";
+
+import {JsonMap} from "./JsonMap.js";
+
+describe("JsonMap", () => {
+  it("should serialize a JsonMap", () => {
+    const map = new JsonMap({
+      id: "id"
+    });
+
+    expect(map.toJSON()).toEqual({
+      id: "id"
+    });
+  });
+});

package/src/domain/JsonMap.ts

@@ -0,0 +1,33 @@
+import {isFunction} from "@tsed/core";
+
+import {JsonSchemaOptions} from "../interfaces/JsonSchemaOptions.js";
+import {execMapper} from "../registries/JsonSchemaMapperContainer.js";
+
+export class JsonMap<T> extends Map<string, any> {
+  [key: string]: any;
+
+  $kind: string = "map";
+  readonly $isJsonDocument = true;
+
+  constructor(obj: Partial<T> = {}) {
+    super();
+
+    this.assign(obj);
+  }
+
+  assign(obj: Partial<T> & any = {}) {
+    Object.entries(obj).forEach(([key, value]) => {
+      if (isFunction(this[key])) {
+        this[key](value);
+      } else {
+        this.set(key, value);
+      }
+    });
+
+    return this;
+  }
+
+  toJSON(options?: JsonSchemaOptions) {
+    return execMapper("map", [this], options);
+  }
+}

package/src/domain/JsonMedia.ts

@@ -0,0 +1,24 @@
+import {OS3MediaType} from "@tsed/openspec";
+
+import {JsonMap} from "./JsonMap.js";
+import {JsonSchema} from "./JsonSchema.js";
+
+export class JsonMedia extends JsonMap<OS3MediaType<JsonSchema>> {
+  $kind: string = "operationMedia";
+
+  groups: string[] = [];
+  groupsName: string;
+  allowedGroups?: Set<string>;
+
+  schema(schema: JsonSchema) {
+    this.set("schema", schema);
+
+    return this;
+  }
+
+  examples(examples: any) {
+    this.set("examples", examples);
+
+    return this;
+  }
+}