@tsed/schema 8.11.1 → 8.11.2-rc.1

package/src/domain/JsonEntityStore.spec.ts

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

@@ -1,292 +0,0 @@
-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;
-      }
-    }
-  }
-
-  set path(path: string) {
-    this.store.set("path", path);
-  }
-
-  get path() {
-    return this.store.get("path");
-  }
-
-  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

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

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

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

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

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