@tsed/schema 8.34.0 → 8.36.0

package/lib/esm/domain/JsonSchema.js

@@ -1,15 +1,16 @@
 import { ancestorOf, ancestorsOf, classOf, isArray, isClass, isFunction, isObject, isPlainObject, isPrimitiveClass, isTemporal, nameOf, uniq } from "@tsed/core";
+import { Discriminator } from "./JsonDiscriminator.js";
 import { Hooks } from "@tsed/hooks";
 import { VendorKeys } from "../constants/VendorKeys.js";
-import { enumsRegistry } from "../registries/enumRegistries.js";
+import { enumsRegistry } from "../registries/enumRegistry.js";
 import { execMapper } from "../registries/JsonSchemaMapperContainer.js";
 import { getComputedType } from "../utils/getComputedType.js";
+import { getJsonEntityStore } from "../registries/JsonEntitiesContainer.js";
 import { getJsonType } from "../utils/getJsonType.js";
+import { getTypeResolver } from "../registries/JsonTypesContainer.js";
 import { matchGroups } from "../utils/matchGroups.js";
 import { serializeEnumValues } from "../utils/serializeEnumValues.js";
 import { toJsonRegex } from "../utils/toJsonRegex.js";
-import { Discriminator } from "./JsonDiscriminator.js";
-import { JsonEntityStore } from "./JsonEntityStore.js";
 function isEnum(type) {
     return isObject(type) && !("toJSON" in type);
 }
@@ -45,7 +46,7 @@ function isEnum(type) {
  *   email: string;
  * }
  *
- * const userSchema = JsonSchema.from(User);
+ * const userSchema = s.from(User);
  *
  * // Generate JSON Schema output
  * const jsonSchema = userSchema.toJSON();
@@ -178,8 +179,8 @@ export class JsonSchema extends Map {
      */
     get discriminatorAncestor() {
         const ancestors = ancestorsOf(this.#target);
-        const ancestor = ancestors.find((ancestor) => JsonEntityStore.from(ancestor).schema.isDiscriminator);
-        return ancestor && JsonEntityStore.from(ancestor).schema;
+        const ancestor = ancestors.find((ancestor) => getJsonEntityStore(ancestor).schema.isDiscriminator);
+        return ancestor && getJsonEntityStore(ancestor).schema;
     }
     /**
      * Get the computed TypeScript class or type for this schema.
@@ -269,33 +270,38 @@ export class JsonSchema extends Map {
      *
      * ```typescript
      * // From a class
-     * const schema1 = JsonSchema.from(User);
+     * const schema1 = s.from(User);
      *
      * // From a primitive
-     * const schema2 = JsonSchema.from(String);
+     * const schema2 = s.from(String);
      *
      * // From a schema object
-     * const schema3 = JsonSchema.from({type: "string", minLength: 1});
+     * const schema3 = s.string().minLength(1);
      *
      * // From existing schema (no-op)
-     * const schema4 = JsonSchema.from(schema1);
+     * const schema4 = s.from(schema1);
      * ```
      *
      * @param item - The input to convert to a JsonSchema
      * @returns A JsonSchema instance representing the input
-     */
-    static from(item) {
-        if (item instanceof JsonSchema) {
-            return item;
-        }
-        if (item && classOf(item) !== Object && isClass(item)) {
-            return JsonEntityStore.from(item).schema;
-        }
-        if (isPrimitiveClass(item) || item === Date || isTemporal(item) || item === null) {
-            return new JsonSchema({ type: item });
-        }
-        return new JsonSchema(item);
-    }
+     * @deprecated
+     */
+    // static from(item: Partial<JsonSchemaObject> | Type<any> | JsonSchema | undefined) {
+    // // console.trace("JsonSchema.from", item)
+    // if (item instanceof JsonSchema) {
+    //   return item;
+    // }
+    //
+    // if (item && classOf(item) !== Object && isClass(item)) {
+    //   return getJsonEntityStore(item).schema;
+    // }
+    //
+    // if (isPrimitiveClass(item) || item === Date || isTemporal(item) || item === null) {
+    //   return new JsonSchema({type: item as Type});
+    // }
+    //
+    // return new JsonSchema(item as Partial<JsonSchemaObject>);
+    // }
     static add(property, method) {
         Object.defineProperty(JsonSchema.prototype, property, {
             value: method,
@@ -437,24 +443,14 @@ export class JsonSchema extends Map {
         this.vendorKey(VendorKeys.GENERIC_LABEL, genericLabel);
         return this;
     }
-    /**
-     * Specify the concrete types for generic parameters.
-     *
-     * When using a generic class, this method assigns the actual types that should
-     * replace the generic parameters for this specific instance.
-     *
-     * ### Usage
-     *
-     * ```typescript
-     * // For Paginated<User>
-     * schema.genericOf([User]);
-     * ```
-     *
-     * @param generics - Arrays of generic type values to apply
-     * @returns This schema instance for method chaining
-     */
     genericOf(...generics) {
-        const mapped = this.mapGenerics(this.#itemSchema || this.mapToJsonSchema(this.getTarget()), generics);
+        if (!generics.length) {
+            return this;
+        }
+        const isGenericsMap = generics.length === 1 && isPlainObject(generics[0]) && Object.values(generics[0]).every(isArray);
+        const mapped = isGenericsMap
+            ? generics[0]
+            : this.mapGenerics(this.#itemSchema || this.toSchema(this.getTarget()), generics.map((generic) => (Array.isArray(generic) ? generic : [generic])));
         this.vendorKey(VendorKeys.GENERIC_OF, mapped);
         return this;
     }
@@ -486,7 +482,7 @@ export class JsonSchema extends Map {
      * @returns The item schema instance
      */
     itemSchema(obj = {}) {
-        this.#itemSchema = this.#itemSchema || this.mapToJsonSchema(obj);
+        this.#itemSchema = this.#itemSchema || this.toSchema(obj);
         if (isPlainObject(obj)) {
             this.#itemSchema.assign(obj);
         }
@@ -714,7 +710,7 @@ export class JsonSchema extends Map {
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
      */
     additionalItems(additionalItems) {
-        super.set("additionalItems", this.mapToJsonSchema(additionalItems));
+        super.set("additionalItems", this.toSchema(additionalItems));
         return this;
     }
     /**
@@ -722,7 +718,7 @@ export class JsonSchema extends Map {
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
      */
     contains(contains) {
-        super.set("contains", this.mapToJsonSchema(contains));
+        super.set("contains", this.toSchema(contains));
         return this;
     }
     /**
@@ -749,8 +745,15 @@ export class JsonSchema extends Map {
      * Set the items' schema for array/set collections
      * @param items The schema for array/set items
      */
-    items(items) {
-        super.set("items", (this.#itemSchema = this.mapToJsonSchema(items)));
+    items(items, init = false) {
+        if (init) {
+            if (!this.has("items")) {
+                super.set("items", this.itemSchema(items));
+            }
+        }
+        else {
+            super.set("items", (this.#itemSchema = this.toSchema(items)));
+        }
         return this;
     }
     $comment(comment) {
@@ -956,8 +959,15 @@ export class JsonSchema extends Map {
      * The default value is an empty schema that allows any value for additional properties.
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
      */
-    additionalProperties(additionalProperties) {
-        super.set("additionalProperties", this.mapToJsonSchema(additionalProperties));
+    additionalProperties(additionalProperties, init = false) {
+        if (init) {
+            if (!this.has("additionalProperties")) {
+                super.set("additionalProperties", this.itemSchema(additionalProperties));
+            }
+        }
+        else {
+            super.set("additionalProperties", this.toSchema(additionalProperties));
+        }
         return this;
     }
     /**
@@ -990,7 +1000,7 @@ export class JsonSchema extends Map {
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
      */
     propertyNames(propertyNames) {
-        super.set("propertyNames", this.mapToJsonSchema(propertyNames));
+        super.set("propertyNames", this.toSchema(propertyNames));
         return this;
     }
     enum(enumValue, ...enumValues) {
@@ -1048,7 +1058,7 @@ export class JsonSchema extends Map {
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
      */
     not(not) {
-        super.set("not", this.mapToJsonSchema(not));
+        super.set("not", this.toSchema(not));
         return this;
     }
     /**
@@ -1151,78 +1161,14 @@ export class JsonSchema extends Map {
      * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
      */
     type(type) {
-        switch (type) {
-            case "map":
-            case Map:
-                super.set("type", getJsonType(type));
-                this.target(type);
-                this.#isCollection = true;
-                if (!this.has("additionalProperties")) {
-                    super.set("additionalProperties", this.itemSchema({}));
-                }
-                break;
-            case "array":
-            case Array:
-                super.set("type", getJsonType(type));
-                this.target(type);
-                this.#isCollection = true;
-                if (!this.has("items")) {
-                    super.set("items", this.itemSchema({}));
-                }
-                break;
-            case "set":
-            case Set:
-                super.set("type", getJsonType(type));
-                this.target(type);
-                this.#isCollection = true;
-                this.uniqueItems(true);
-                if (!this.has("items")) {
-                    super.set("items", this.itemSchema({}));
-                }
-                break;
-            case "integer":
-                this.integer();
-                break;
-            case "number":
-            case "string":
-            case "boolean":
-            case "object":
-            case Object:
-            case Date:
-            case Boolean:
-            case Number:
-            case String:
-                super.set("type", getJsonType(type));
-                this.target(type);
-                if (!this.has("properties")) {
-                    super.set("properties", {});
-                }
-                break;
-            default:
-                if (isTemporal(type)) {
-                    // Temporal.* types serialize to an ISO-8601 string, like Date.
-                    super.set("type", getJsonType(type));
-                    this.target(type);
-                    if (!this.has("properties")) {
-                        super.set("properties", {});
-                    }
-                }
-                else if (isClass(type) || isFunction(type)) {
-                    super.set("type", undefined);
-                    this.target(type);
-                    if (!this.has("properties")) {
-                        super.set("properties", {});
-                    }
-                }
-                else {
-                    const jsonType = getJsonType(type);
-                    if (jsonType === "generic") {
-                        this.genericLabel(type);
-                    }
-                    else {
-                        super.set("type", jsonType);
-                    }
-                }
+        const resolver = getTypeResolver(type);
+        if (resolver) {
+            const jsonType = resolver.jsonType?.(type);
+            jsonType && super.set("type", jsonType);
+            resolver?.init?.(this, type);
+        }
+        else {
+            super.set("type", getJsonType(type));
         }
         return this;
     }
@@ -1317,8 +1263,8 @@ export class JsonSchema extends Map {
         }
         return this;
     }
-    set(key, value) {
-        if (key in this) {
+    set(key, value, force = false) {
+        if (key in this && !force) {
             isFunction(this[key]) && this[key](value);
         }
         else {
@@ -1365,7 +1311,7 @@ export class JsonSchema extends Map {
         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 ancestor === Object ? undefined : getJsonEntityStore(ancestor).schema.getGenericLabels();
         }
         return this.get(VendorKeys.GENERIC_LABELS);
     }
@@ -1379,7 +1325,7 @@ export class JsonSchema extends Map {
      */
     getRefSchema() {
         if (!this.isLocalSchema && this.isClass) {
-            const refSchema = JsonSchema.from(this.class);
+            const refSchema = getJsonEntityStore(this.class).schema;
             if (refSchema !== this) {
                 return refSchema;
             }
@@ -1396,9 +1342,10 @@ export class JsonSchema extends Map {
         if (target === "object") {
             this.#target = Object;
         }
-        else {
+        else if (typeof target !== "string") {
             this.#target = target;
         }
+        return this;
     }
     isRequiredValue(property, value) {
         if (this.isRequired(property) && [undefined, null, ""].includes(value)) {
@@ -1409,6 +1356,14 @@ export class JsonSchema extends Map {
         }
         return false;
     }
+    toCollection() {
+        this.#isCollection = true;
+        return this;
+    }
+    unsetType() {
+        super.set("type", undefined);
+        return this;
+    }
     setManyOf(keyword, value) {
         let resolved = value
             .filter((o) => {
@@ -1418,7 +1373,7 @@ export class JsonSchema extends Map {
             }
             return true;
         })
-            .map((item) => this.mapToJsonSchema(item));
+            .map((item) => this.toSchema(item));
         if (resolved.length === 1 && !(value[0] instanceof JsonSchema) && !this.isNullable) {
             if (!resolved[0].hasDiscriminator) {
                 return this.type(value[0]);
@@ -1427,7 +1382,7 @@ export class JsonSchema extends Map {
             if (!children.length) {
                 return this.type(value[0]);
             }
-            resolved = children.map((item) => this.mapToJsonSchema(item));
+            resolved = children.map((item) => this.toSchema(item));
         }
         super.set(keyword, resolved);
         const jsonSchema = resolved[0];
@@ -1447,21 +1402,21 @@ export class JsonSchema extends Map {
             this.#discriminator = discriminator;
         }
     }
-    mapToJsonSchema(item) {
+    toSchema(item) {
         if (isArray(item)) {
-            return item.map((item) => this.mapToJsonSchema(item));
+            return item.map((item) => this.toSchema(item));
         }
         if (item && (item.isStore || item.$isJsonDocument || item.isLazyRef)) {
             return item;
         }
         if (item && classOf(item) !== Object && isClass(item)) {
-            return JsonEntityStore.from(item).schema;
+            return getJsonEntityStore(item).schema;
         }
         if (isObject(item)) {
-            return JsonSchema.from(item);
+            return new JsonSchema(item);
         }
         if (isPrimitiveClass(item) || item === Date || isTemporal(item) || item === null) {
-            return JsonSchema.from({ type: item });
+            return new JsonSchema({ type: item });
         }
         return item;
     }
@@ -1489,14 +1444,14 @@ export class JsonSchema extends Map {
             const label = genericLabels[index];
             if (label) {
                 if (isEnum(type)) {
-                    mapping[label] = [JsonSchema.from({ type: "string", enum: Object.values(type) })];
+                    mapping[label] = [new JsonSchema({ type: "string", enum: Object.values(type) })];
                 }
                 else if (nextTypes.length) {
-                    const nextSchema = this.mapToJsonSchema(type);
+                    const nextSchema = this.toSchema(type);
                     mapping[label] = [nextSchema, this.mapGenerics(nextSchema, nextTypes)];
                 }
                 else {
-                    mapping[label] = [this.mapToJsonSchema(type)];
+                    mapping[label] = [this.toSchema(type)];
                 }
             }
             return mapping;
@@ -1508,7 +1463,7 @@ export class JsonSchema extends Map {
             return properties;
         }
         return Object.entries(properties).reduce((properties, [key, schema]) => {
-            properties[toJsonRegex(key)] = this.mapToJsonSchema(schema);
+            properties[toJsonRegex(key)] = this.toSchema(schema);
             if (schema instanceof JsonSchema) {
                 schema.propertyKey(toJsonRegex(key));
             }

package/lib/esm/domain/index.js

@@ -0,0 +1,26 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./DecoratorContext.js";
+export * from "./Generics.js";
+export * from "./IgnoreCallback.js";
+export * from "./JsonAliasMap.js";
+export * from "./JsonDiscriminator.js";
+export * from "./JsonEntityStore.js";
+export * from "./JsonFormatTypes.js";
+export * from "./JsonHookContext.js";
+export * from "./JsonLazyRef.js";
+export * from "./JsonMap.js";
+export * from "./JsonMedia.js";
+export * from "./JsonOpenSpec.js";
+export * from "./JsonOperation.js";
+export * from "./JsonOperationPathsMap.js";
+export * from "./JsonOperationRoute.js";
+export * from "./JsonParameter.js";
+export * from "./JsonParameterTypes.js";
+export * from "./JsonRequestBody.js";
+export * from "./JsonResponse.js";
+export * from "./JsonSchema.js";
+export * from "./JsonSchemaOptions.js";
+export * from "./SpecTypes.js";
+export * from "./types.js";

package/lib/esm/fn/compile.js

@@ -0,0 +1,82 @@
+import "../components/index.js";
+import { DecoratorTypes, getValue, isClass, isPlainObject, nameOf } from "@tsed/core";
+import { JsonSchema, SpecTypes } from "../domain/index.js";
+import { execMapper } from "../registries/JsonSchemaMapperContainer.js";
+import { getJsonEntityStore } from "../registries/JsonEntitiesContainer.js";
+import { inlineRefs } from "../utils/inlineRefs.js";
+/**
+ * @ignore
+ */
+const CACHES = new Map();
+/**
+ * @ignore
+ */
+function getKey(options) {
+    return JSON.stringify(options, (key, value) => {
+        if (value && !isPlainObject(value) && isClass(value)) {
+            return nameOf(value);
+        }
+        return value;
+    });
+}
+/**
+ * @ignore
+ */
+function get(model, options) {
+    const cache = CACHES.get(model) || new Map();
+    CACHES.set(model, cache);
+    const key = getKey(options);
+    if (!cache.has(key)) {
+        let schema;
+        if (model instanceof JsonSchema) {
+            schema = model.toJSON(options);
+        }
+        else {
+            const entity = getJsonEntityStore(model);
+            let mapper = "schema";
+            if (entity.is(DecoratorTypes.PARAM)) {
+                options = {
+                    ...options,
+                    root: true,
+                    groups: entity.schema.getGroups()
+                };
+                mapper = "item";
+            }
+            schema = execMapper(mapper, [entity.schema], options);
+        }
+        if (Object.keys(getValue(options, "components.schemas", {})).length) {
+            schema.definitions = options.components.schemas;
+        }
+        cache.set(key, options.inlineRefs ? inlineRefs(schema) : schema);
+    }
+    return cache.get(key);
+}
+/**
+ * Compile a class, parameter store, or `JsonSchema` into a plain JSON schema object.
+ *
+ * This is an alias of `getJsonSchema(...)`.
+ *
+ * @param model Class, parameter store, or `JsonSchema` to compile.
+ * @param options JSON schema generation options.
+ * @returns Compiled JSON schema object.
+ */
+export function compile(model, options = {}) {
+    const specType = options.specType || SpecTypes.JSON;
+    options = {
+        endpoint: true,
+        groups: [],
+        inlineEnums: specType === SpecTypes.JSON,
+        ...options,
+        specType,
+        components: {
+            schemas: {}
+        }
+    };
+    return get(model, options);
+}
+/**
+ * @deprecated Use s.compile() instead
+ * @param model
+ * @param options
+ */
+export const getJsonSchema = compile;

package/lib/esm/fn/enums.js

@@ -1,4 +1,4 @@
-import { enumsRegistry } from "../registries/enumRegistries.js";
+import { enumsRegistry } from "../registries/enumRegistry.js";
 import { from } from "./from.js";
 export function enums(e) {
     const schema = from().enum(e);

package/lib/esm/fn/from.js

@@ -1,16 +1,39 @@
 import { isClass } from "@tsed/core";
 import { JsonSchema } from "../domain/JsonSchema.js";
-import { getJsonEntityStore } from "../utils/getJsonEntityStore.js";
+import { getJsonEntityStore } from "../registries/JsonEntitiesContainer.js";
 export function from(type = Object) {
     if (isClass(type)) {
         const { schema } = getJsonEntityStore(type);
-        schema.properties = function properties(obj) {
-            Object.entries(obj).forEach(([propertyKey, propSchema]) => {
-                getJsonEntityStore(type.prototype, propertyKey).schema.assign(propSchema);
-            });
-            return this;
-        };
-        return schema;
+        return schema.clone();
     }
-    return JsonSchema.from({ type });
+    return new JsonSchema({ type });
+}
+/**
+ * Get the shared schema instance attached to a class.
+ *
+ * Contrary to @@from@@, `get()` returns the schema stored in the class metadata.
+ * Mutating the returned instance updates the class-level schema definition and
+ * therefore affects every consumer of that class schema.
+ *
+ * This helper is intended for low-level or internal patching scenarios where the
+ * source schema must be updated in place.
+ *
+ * ```typescript
+ * get(UserModel).properties({
+ *   name: string()
+ * });
+ * ```
+ *
+ * @param type The class owning the shared schema metadata.
+ * @returns The shared `JsonSchema` instance for the class.
+ */
+export function get(type) {
+    const { schema } = getJsonEntityStore(type);
+    schema.properties = function properties(obj) {
+        Object.entries(obj).forEach(([propertyKey, propSchema]) => {
+            getJsonEntityStore(type.prototype, propertyKey).schema.assign(propSchema);
+        });
+        return this;
+    };
+    return schema;
 }

package/lib/esm/fn/generic.js

@@ -0,0 +1,9 @@
+import { from } from "./from.js";
+export function generic(type = Object) {
+    function of(...generics) {
+        return from(type).genericOf(...generics);
+    }
+    return {
+        of
+    };
+}

package/lib/esm/fn/index.js

@@ -1,14 +1,20 @@
+import { array, map, record, set } from "./collection.js";
+import { date, datetime, time } from "./date.js";
+import { from, get } from "./from.js";
+import { getJsonEntityStore, getJsonMethodStore } from "../registries/JsonEntitiesContainer.js";
 import { allOf } from "./allOf.js";
 import { any } from "./any.js";
 import { anyOf } from "./anyOf.js";
 import { boolean } from "./boolean.js";
-import { array, map, record, set } from "./collection.js";
-import { date, datetime, time } from "./date.js";
+import { compile } from "./compile.js";
+import { compileSpec } from "./oas/compileSpec.js";
 import { email } from "./email.js";
 import { enums } from "./enums.js";
-import { from } from "./from.js";
+import { generic } from "./generic.js";
 import { integer } from "./integer.js";
 import { lazyRef } from "./lazyRef.js";
+import { mergeSchema } from "../utils/mergeSchema.js";
+import { mergeSpec } from "./oas/mergeSpec.js";
 import { number } from "./number.js";
 import { object } from "./object.js";
 import { oneOf } from "./oneOf.js";
@@ -43,5 +49,20 @@ export const s = {
     $ref: ref,
     string,
     uri,
-    url
+    url,
+    generic,
+    get,
+    store: Object.assign(getJsonEntityStore, {
+        get: getJsonEntityStore,
+        method: getJsonMethodStore
+    }),
+    schema: {
+        compile,
+        merge: mergeSchema
+    },
+    compile,
+    oas: Object.assign(compileSpec, {
+        compile: compileSpec,
+        merge: mergeSpec
+    })
 };

package/lib/esm/fn/lazyRef.js

@@ -1,11 +1,11 @@
-import { JsonEntityStore } from "../domain/JsonEntityStore.js";
-import { JsonLazyRef } from "../domain/JsonLazyRef.js";
+import { JsonLazyRef } from "../domain/index.js";
+import { getJsonEntityStore } from "../registries/JsonEntitiesContainer.js";
 export function lazyRef(cb) {
     try {
         // solve issue with a self referenced model
         if (cb()) {
             // type is already accessible
-            return JsonEntityStore.from(cb()).schema;
+            return getJsonEntityStore(cb()).schema;
         }
     }
     catch (er) { }

package/lib/esm/fn/oas/compileSpec.js

@@ -0,0 +1,9 @@
+import { generateSpec } from "./generateSpec.js";
+import { getSpec } from "./getSpec.js";
+import { isPlainObject } from "@tsed/core";
+export function compileSpec(modelOrOptions, options) {
+    if (!isPlainObject(modelOrOptions) || options) {
+        return getSpec(modelOrOptions, options);
+    }
+    return generateSpec(modelOrOptions);
+}

package/lib/esm/{utils → fn/oas}/generateSpec.js

@@ -1,7 +1,7 @@
-import { getValue } from "@tsed/core";
-import { SpecTypes } from "../domain/SpecTypes.js";
 import { getSpec } from "./getSpec.js";
+import { SpecTypes } from "../../domain/SpecTypes.js";
 import { getSpecTypeFromSpec } from "./getSpecType.js";
+import { getValue } from "@tsed/core";
 import { mapOpenSpec } from "./mapOpenSpec.js";
 import { mergeSpec } from "./mergeSpec.js";
 import { transformToOS2 } from "./transformToOS2.js";