@tsed/schema 8.13.5 → 8.14.0

package/lib/esm/domain/JsonPropertyStore.js

@@ -1,5 +1,5 @@
 import { __decorate } from "tslib";
-import { DecoratorTypes, Metadata, prototypeOf } from "@tsed/core";
+import { DecoratorTypes, isClass, Metadata, prototypeOf } from "@tsed/core";
 import { JsonEntityComponent } from "../decorators/config/jsonEntityComponent.js";
 import { JsonEntityStore } from "./JsonEntityStore.js";
 import { JsonSchema } from "./JsonSchema.js";
@@ -8,43 +8,8 @@ let JsonPropertyStore = class JsonPropertyStore extends JsonEntityStore {
         super(...arguments);
         this.parent = JsonEntityStore.from(this.target);
     }
-    /**
-     * Return the required state.
-     * @returns {boolean}
-     */
-    get required() {
-        return this.parent.schema.isRequired(this.propertyKey);
-    }
-    /**
-     * Change the state of the required data.
-     * @param value
-     */
-    set required(value) {
-        if (value) {
-            this.parent.schema.addRequired(this.propertyKey);
-        }
-        else {
-            this.parent.schema.removeRequired(this.propertyKey);
-        }
-    }
-    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) {
-        return this.required && [undefined, null, ""].includes(value) && !this.allowedRequiredValues.includes(value);
+    static get(target, propertyKey) {
+        return JsonEntityStore.from(prototypeOf(target), propertyKey);
     }
     build() {
         if (!this._type) {
@@ -55,19 +20,23 @@ let JsonPropertyStore = class JsonPropertyStore extends JsonEntityStore {
         let schema = properties[this.propertyName];
         if (!schema) {
             this.parent.children.set(this.propertyName, this);
-            schema = JsonSchema.from({
-                type: this.collectionType || this.type
-            });
-            if (this.collectionType) {
+            if (this.isCollection) {
+                schema = JsonSchema.from({
+                    type: this.collectionType
+                });
+                schema.itemSchema(this.type);
+            }
+            else if (isClass(this.type)) {
+                schema = JsonSchema.from({ type: "object" });
                 schema.itemSchema(this.type);
             }
+            else {
+                schema = JsonSchema.from({ type: this.type });
+            }
         }
         this.parent.schema.addProperty(this.propertyName, schema);
         this._schema = schema;
     }
-    static get(target, propertyKey) {
-        return JsonEntityStore.from(prototypeOf(target), propertyKey);
-    }
 };
 JsonPropertyStore = __decorate([
     JsonEntityComponent(DecoratorTypes.PROP)

package/lib/esm/domain/JsonSchema.js

@@ -1,9 +1,11 @@
-import { ancestorsOf, classOf, isArray, isClass, isFunction, isObject, isPrimitiveClass, nameOf, uniq } from "@tsed/core";
+import { ancestorOf, ancestorsOf, classOf, isArray, isClass, isFunction, isObject, isPlainObject, isPrimitiveClass, nameOf, uniq } from "@tsed/core";
 import { Hooks } from "@tsed/hooks";
+import { VendorKeys } from "../constants/VendorKeys.js";
 import { enumsRegistry } from "../registries/enumRegistries.js";
 import { execMapper } from "../registries/JsonSchemaMapperContainer.js";
 import { getComputedType } from "../utils/getComputedType.js";
 import { getJsonType } from "../utils/getJsonType.js";
+import { matchGroups } from "../utils/matchGroups.js";
 import { serializeEnumValues } from "../utils/serializeEnumValues.js";
 import { toJsonRegex } from "../utils/toJsonRegex.js";
 import { Discriminator } from "./JsonDiscriminator.js";
@@ -15,6 +17,9 @@ function mapProperties(properties) {
     }
     return Object.entries(properties).reduce((properties, [key, schema]) => {
         properties[toJsonRegex(key)] = mapToJsonSchema(schema);
+        if (schema instanceof JsonSchema) {
+            schema.propertyKey(toJsonRegex(key));
+        }
         return properties;
     }, {});
 }
@@ -36,35 +41,83 @@ function mapToJsonSchema(item) {
     }
     return item;
 }
+function isEnum(type) {
+    return isObject(type) && !("toJSON" in type);
+}
+function mapGenerics(jsonSchema, generics) {
+    const genericLabels = jsonSchema.getGenericLabels();
+    if (!genericLabels) {
+        return {};
+    }
+    const [types, ...nextTypes] = generics;
+    return types.reduce((mapping, type, index) => {
+        const label = genericLabels[index];
+        if (label) {
+            if (isEnum(type)) {
+                mapping[label] = [JsonSchema.from({ type: "string", enum: Object.values(type) })];
+            }
+            else if (nextTypes.length) {
+                const nextSchema = mapToJsonSchema(type);
+                mapping[label] = [nextSchema, mapGenerics(nextSchema, nextTypes)];
+            }
+            else {
+                mapping[label] = [mapToJsonSchema(type)];
+            }
+        }
+        return mapping;
+    }, {});
+}
 export class JsonSchema extends Map {
-    #nullable;
+    /**
+     * All required fields are stored here
+     * @private
+     */
+    #required;
+    /**
+     * Internal custom props
+     * @private
+     */
+    #vendors;
     #discriminator;
-    #genericLabels;
-    #nestedGenerics;
     #alias;
     #itemSchema;
+    /**
+     * This flag is used to know if the schema is created to link property/param to a class schema.
+     * @private
+     */
+    #isLocalSchema;
     #target;
-    #isGeneric;
     #isCollection;
-    #ref;
+    #useRefLabel;
+    #propertyKey;
     constructor(obj = {}) {
         super();
         this.$kind = "schema";
         this.$isJsonDocument = true;
         this.$hooks = new Hooks();
-        this.$required = new Set();
         this.$allow = [];
-        this.$forwardGroups = false;
         this.$ignore = false;
         this.isDiscriminatorKey = false;
         this.isDiscriminator = false;
-        this.#nullable = false;
+        /**
+         * All required fields are stored here
+         * @private
+         */
+        this.#required = new Set();
+        /**
+         * Internal custom props
+         * @private
+         */
+        this.#vendors = new Map();
         this.#discriminator = null;
-        this.#nestedGenerics = [];
         this.#alias = new Map();
-        this.#isGeneric = false;
+        /**
+         * This flag is used to know if the schema is created to link property/param to a class schema.
+         * @private
+         */
+        this.#isLocalSchema = false;
         this.#isCollection = false;
-        this.#ref = false;
+        this.#useRefLabel = false;
         if (obj) {
             this.assign(obj);
         }
@@ -72,32 +125,27 @@ export class JsonSchema extends Map {
     get alias() {
         return this.#alias;
     }
-    get nestedGenerics() {
-        return this.#nestedGenerics;
-    }
-    set nestedGenerics(value) {
-        this.#nestedGenerics = value;
-    }
-    get genericLabels() {
-        return this.#genericLabels;
-    }
-    set genericLabels(value) {
-        this.#genericLabels = value;
-    }
     get isClass() {
-        return isClass(this.class) && ![Map, Array, Set, Object, Date, Boolean, Number, String].includes(this.#target);
+        return isClass(this.class) && !this.isCollection;
     }
     /**
-     * Current schema is a collection
+     * The current schema is a collection
      */
     get isCollection() {
         return this.#isCollection;
     }
+    /**
+     * The current schema is a reference to another schema
+     * to link property/param to a class schema (if the reference exists).
+     */
+    get isLocalSchema() {
+        return this.#isLocalSchema;
+    }
     /**
      * Current schema is a generic
      */
     get isGeneric() {
-        return this.#isGeneric;
+        return this.has(VendorKeys.GENERIC_LABEL);
     }
     get discriminatorAncestor() {
         const ancestors = ancestorsOf(this.#target);
@@ -105,22 +153,27 @@ export class JsonSchema extends Map {
         return ancestor && JsonEntityStore.from(ancestor).schema;
     }
     /**
-     * Current schema has generics items
+     * Return the itemSchema computed type.
+     * If the type is a function used for a recursive model,
+     * the function will be called to get the right type.
      */
-    get hasGenerics() {
-        return !!(this.nestedGenerics && this.nestedGenerics.length);
-    }
-    get genericType() {
-        return this.get("$ref");
-    }
     get class() {
-        return this.getComputedType();
+        if (this.#isLocalSchema) {
+            return this.#itemSchema?.getTarget();
+        }
+        return getComputedType(this.#target);
+    }
+    /**
+     * Return the itemSchema computed type.
+     */
+    get collectionClass() {
+        return this.isCollection && this.#itemSchema ? this.#itemSchema.class : this.class;
     }
     get canRef() {
-        return this.#ref;
+        return this.#useRefLabel;
     }
     get isNullable() {
-        return this.#nullable;
+        return !!this.get("nullable");
     }
     get isReadOnly() {
         return this.get("readOnly");
@@ -131,15 +184,105 @@ export class JsonSchema extends Map {
     get hasDiscriminator() {
         return !!this.#discriminator;
     }
-    static from(obj = {}) {
-        return new JsonSchema(obj);
+    static from(item = {}) {
+        if (item instanceof JsonSchema) {
+            return item;
+        }
+        if (classOf(item) !== Object && isClass(item)) {
+            return JsonEntityStore.from(item).schema;
+        }
+        if (isPrimitiveClass(item)) {
+            return new JsonSchema({ type: item });
+        }
+        return new JsonSchema(item);
+    }
+    /**
+     * Check if the schema as key, #key or x-key
+     * @param key
+     */
+    has(key) {
+        if (super.has(key)) {
+            return true;
+        }
+        if (super.has(`#${key}`)) {
+            return true;
+        }
+        return this.#vendors.has(key);
+    }
+    get(key, defaultValue) {
+        if (this.#vendors.has(key)) {
+            return this.#vendors.get(key);
+        }
+        if (super.has(key)) {
+            return super.get(key);
+        }
+        if (super.has(`#${key}`)) {
+            return super.get(`#${key}`);
+        }
+        return defaultValue;
+    }
+    forwardGroups(bool = true) {
+        this.vendorKey(VendorKeys.FORWARD_GROUPS, bool);
+        return this;
+    }
+    groups(groups, isProperty) {
+        if (groups) {
+            this.vendorKey(VendorKeys.GROUPS, groups);
+            // this.customKey("x-groups", groups);
+            if (isProperty) {
+                this.$hooks.on("groups", (prev, givenGroups) => {
+                    if (!prev) {
+                        if (matchGroups(groups, givenGroups)) {
+                            return true;
+                        }
+                    }
+                    return prev;
+                });
+            }
+        }
+        return this;
+    }
+    groupsName(groupsName) {
+        groupsName && this.vendorKey(VendorKeys.GROUPS_NAME, groupsName);
+        return this;
+    }
+    allowedGroups(groups) {
+        groups && this.vendorKey(VendorKeys.ALLOWED_GROUPS, groups);
+        return this;
+    }
+    /**
+     * Assign the Generic Labels used over a class or a schema.
+     * @param genericLabels
+     */
+    genericLabels(genericLabels) {
+        this.vendorKey(VendorKeys.GENERIC_LABELS, genericLabels);
+        return this;
+    }
+    genericLabel(genericLabel) {
+        this.vendorKey(VendorKeys.GENERIC_LABEL, genericLabel);
+        return this;
+    }
+    /**
+     * Assign the types of the generics that must be used for the property
+     * @param generics
+     */
+    genericOf(...generics) {
+        const mapped = mapGenerics(this.#itemSchema || mapToJsonSchema(this.getTarget()), generics);
+        this.vendorKey(VendorKeys.GENERIC_OF, mapped);
+        return this;
     }
     nullable(value) {
-        this.#nullable = value;
+        this.vendorKey(VendorKeys.NULLABLE, value);
+        return this;
     }
     itemSchema(obj = {}) {
         this.#itemSchema = this.#itemSchema || mapToJsonSchema(obj);
-        this.#itemSchema.assign(obj);
+        if (isPlainObject(obj)) {
+            this.#itemSchema.assign(obj);
+        }
+        if (!this.isCollection && this.#itemSchema?.isClass) {
+            this.#isLocalSchema = true;
+        }
         return this.#itemSchema;
     }
     getAliasOf(property) {
@@ -173,7 +316,7 @@ export class JsonSchema extends Map {
      * @param name
      */
     label(name) {
-        this.#ref = true;
+        this.#useRefLabel = true;
         super.set("name", name);
         return this;
     }
@@ -225,6 +368,15 @@ export class JsonSchema extends Map {
     discriminatorKey(propertyName) {
         this.discriminator().propertyName = propertyName;
         this.isDiscriminator = true;
+        const propertySchema = this.get("properties")[propertyName];
+        if (propertySchema) {
+            if (propertySchema.isCollection) {
+                propertySchema.itemSchema().isDiscriminatorKey = true;
+            }
+            else {
+                propertySchema.isDiscriminatorKey = true;
+            }
+        }
         return this;
     }
     discriminatorValue(...values) {
@@ -368,8 +520,8 @@ export class JsonSchema extends Map {
      */
     required(required = true) {
         if (isArray(required)) {
-            this.$required.clear();
-            required.forEach((value) => this.$required.add(value));
+            this.#required.clear();
+            required.forEach((value) => this.#required.add(value));
         }
         else {
             const schema = this.clone();
@@ -382,15 +534,18 @@ export class JsonSchema extends Map {
         return this;
     }
     addRequired(property) {
-        this.$required.add(property);
+        this.#required.add(property);
         return this;
     }
     removeRequired(property) {
-        this.$required.delete(property);
+        this.#required.delete(property);
         return this;
     }
     isRequired(property) {
-        return this.$required.has(property);
+        return this.#required.has(property);
+    }
+    getRequiredFields() {
+        return [...this.#required];
     }
     /**
      * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
@@ -508,7 +663,12 @@ export class JsonSchema extends Map {
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
      */
     oneOf(oneOf) {
-        this.setManyOf("oneOf", oneOf);
+        if (this.isCollection) {
+            this.itemSchema().oneOf(oneOf);
+        }
+        else {
+            this.setManyOf("oneOf", oneOf);
+        }
         return this;
     }
     /**
@@ -606,7 +766,7 @@ export class JsonSchema extends Map {
             case "map":
             case Map:
                 super.set("type", getJsonType(type));
-                this.#target = type;
+                this.target(type);
                 this.#isCollection = true;
                 if (!this.has("additionalProperties")) {
                     super.set("additionalProperties", this.itemSchema({}));
@@ -615,7 +775,7 @@ export class JsonSchema extends Map {
             case "array":
             case Array:
                 super.set("type", getJsonType(type));
-                this.#target = type;
+                this.target(type);
                 this.#isCollection = true;
                 if (!this.has("items")) {
                     super.set("items", this.itemSchema({}));
@@ -624,7 +784,7 @@ export class JsonSchema extends Map {
             case "set":
             case Set:
                 super.set("type", getJsonType(type));
-                this.#target = type;
+                this.target(type);
                 this.#isCollection = true;
                 this.uniqueItems(true);
                 if (!this.has("items")) {
@@ -644,7 +804,7 @@ export class JsonSchema extends Map {
             case Number:
             case String:
                 super.set("type", getJsonType(type));
-                this.#target = type;
+                this.target(type);
                 if (!this.has("properties")) {
                     super.set("properties", {});
                 }
@@ -652,7 +812,7 @@ export class JsonSchema extends Map {
             default:
                 if (isClass(type) || isFunction(type)) {
                     super.set("type", undefined);
-                    this.#target = type;
+                    this.target(type);
                     if (!this.has("properties")) {
                         super.set("properties", {});
                     }
@@ -660,8 +820,7 @@ export class JsonSchema extends Map {
                 else {
                     const jsonType = getJsonType(type);
                     if (jsonType === "generic") {
-                        this.#isGeneric = true;
-                        super.set("$ref", type);
+                        this.genericLabel(type);
                     }
                     else {
                         super.set("type", jsonType);
@@ -709,6 +868,10 @@ export class JsonSchema extends Map {
         super.set(`#${key}`, value);
         return this;
     }
+    vendorKey(key, value) {
+        this.#vendors.set(key, value);
+        return this;
+    }
     toObject(options) {
         return this.toJSON(options);
     }
@@ -723,21 +886,16 @@ export class JsonSchema extends Map {
         if (obj instanceof JsonSchema) {
             this.$selfRequired = obj.$selfRequired;
             this.$allow.push(...obj.$allow);
-            obj.$required.forEach((key) => {
-                this.$required.add(key);
-            });
+            this.#required = new Set(obj.#required.keys());
+            this.#alias = new Map(this.#alias.entries());
+            this.#vendors = new Map(obj.#vendors.entries());
             this.#discriminator = this.#discriminator ? new Discriminator(this.#discriminator) : null;
             this.isDiscriminator = obj.isDiscriminator;
             this.isDiscriminatorKey = obj.isDiscriminatorKey;
-            this.#ref = obj.#ref;
-            this.#alias = new Map(this.#alias.entries());
-            obj.#genericLabels && (this.#genericLabels = [...obj.#genericLabels]);
-            this.#nestedGenerics = obj.#nestedGenerics.map((item) => [...item]);
+            this.#useRefLabel = obj.#useRefLabel;
             this.#target = obj.#target;
-            this.#isGeneric = obj.#isGeneric;
             this.#isCollection = obj.#isCollection;
-            this.#ref = obj.#ref;
-            this.#nullable = obj.#nullable;
+            this.#isLocalSchema = obj.#isLocalSchema;
             super.set("type", obj.get("type"));
         }
         return this;
@@ -751,17 +909,6 @@ export class JsonSchema extends Map {
         }
         return this;
     }
-    /**
-     * 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.
-     */
-    getComputedType() {
-        return getComputedType(this.#target);
-    }
-    getComputedItemType() {
-        return this.#itemSchema ? this.#itemSchema.getComputedType() : this.getComputedType();
-    }
     /**
      * Return the Json type as string
      */
@@ -771,24 +918,84 @@ export class JsonSchema extends Map {
                 return o.getJsonType();
             });
         }
-        return this.get("type") || getJsonType(this.getComputedType());
+        return this.get("type") || getJsonType(this.class);
     }
     getTarget() {
         return this.#target;
     }
+    getAllowedGroups() {
+        return this.get(VendorKeys.ALLOWED_GROUPS);
+    }
+    getAllowedRequiredValues() {
+        return this.$allow;
+    }
+    getGroups() {
+        return this.get(VendorKeys.GROUPS);
+    }
+    getGroupsName() {
+        return this.get(VendorKeys.GROUPS_NAME);
+    }
     /**
      * Get the symbolic name of the entity
      */
     getName() {
-        return this.get("name") || (isClass(this.#target) ? nameOf(classOf(this.getComputedType())) : "");
+        return this.get("name") || (isClass(this.#target) ? nameOf(classOf(this.class)) : "");
     }
     clone() {
         return new JsonSchema(this);
     }
+    getGenericLabels() {
+        const labels = this.get(VendorKeys.GENERIC_LABELS);
+        if (this.isClass && !labels) {
+            const ancestor = ancestorOf(this.class);
+            return ancestor === Object ? undefined : JsonSchema.from(ancestor).getGenericLabels();
+        }
+        return this.get(VendorKeys.GENERIC_LABELS);
+    }
+    getGenericOf() {
+        return this.get(VendorKeys.GENERIC_OF);
+    }
+    /**
+     * Returns the reference schema for class-based schemas.
+     * Used to get the original schema definition when this schema is a local reference.
+     * @returns The reference schema or undefined if not applicable
+     */
+    getRefSchema() {
+        if (!this.isLocalSchema && this.isClass) {
+            const refSchema = JsonSchema.from(this.class);
+            if (refSchema !== this) {
+                return refSchema;
+            }
+        }
+    }
+    propertyKey(s) {
+        this.#propertyKey = s;
+        return this;
+    }
+    getPropertyKey() {
+        return this.#propertyKey;
+    }
+    target(target) {
+        if (target === "object") {
+            this.#target = Object;
+        }
+        else {
+            this.#target = target;
+        }
+    }
+    isRequiredValue(property, value) {
+        if (this.isRequired(property) && [undefined, null, ""].includes(value)) {
+            const propertySchema = this.get("properties")?.[property];
+            if (propertySchema) {
+                return !propertySchema.getAllowedRequiredValues().includes(value);
+            }
+        }
+        return false;
+    }
     setManyOf(keyword, value) {
         let resolved = value
             .filter((o) => {
-            if (o?.type === "null") {
+            if (o && "type" in o && o.type === "null") {
                 this.nullable(true);
                 return false;
             }
@@ -807,7 +1014,7 @@ export class JsonSchema extends Map {
         }
         super.set(keyword, resolved);
         const jsonSchema = resolved[0];
-        if (jsonSchema.isDiscriminator) {
+        if (jsonSchema?.isDiscriminator) {
             const discriminator = jsonSchema.discriminatorAncestor.discriminator();
             const { propertyName } = discriminator;
             super.set("discriminator", {

package/lib/esm/fn/email.js

@@ -1,5 +1,5 @@
 import { JsonFormatTypes } from "../domain/JsonFormatTypes.js";
-import { from } from "./from.js";
+import { string } from "./string.js";
 /**
  * Declare a new string model with `format: email`.
  *
@@ -13,5 +13,5 @@ import { from } from "./from.js";
  * ```
  */
 export function email() {
-    return from(String).format(JsonFormatTypes.EMAIL);
+    return string().format(JsonFormatTypes.EMAIL);
 }

package/lib/esm/fn/uri.js

@@ -1,5 +1,5 @@
 import { JsonFormatTypes } from "../domain/JsonFormatTypes.js";
-import { from } from "./from.js";
+import { string } from "./string.js";
 /**
  * Declare a new string model with `format: uri`.
  *
@@ -8,5 +8,5 @@ import { from } from "./from.js";
  * @schemaFunctional
  */
 export function uri() {
-    return from(String).format(JsonFormatTypes.URI);
+    return string().format(JsonFormatTypes.URI);
 }