@tsed/schema 8.35.0 → 8.36.0

package/lib/esm/fn/compile.js

@@ -3,6 +3,7 @@ import { DecoratorTypes, getValue, isClass, isPlainObject, nameOf } from "@tsed/
 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
  */
@@ -26,25 +27,27 @@ function get(model, options) {
     CACHES.set(model, cache);
     const key = getKey(options);
     if (!cache.has(key)) {
+        let schema;
         if (model instanceof JsonSchema) {
-            cache.set(key, model.toJSON(options));
-            return cache.get(key);
+            schema = model.toJSON(options);
         }
-        const entity = getJsonEntityStore(model);
-        let mapper = "schema";
-        if (entity.is(DecoratorTypes.PARAM)) {
-            options = {
-                ...options,
-                root: true,
-                groups: entity.schema.getGroups()
-            };
-            mapper = "item";
+        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);
         }
-        const schema = execMapper(mapper, [entity.schema], options);
         if (Object.keys(getValue(options, "components.schemas", {})).length) {
             schema.definitions = options.components.schemas;
         }
-        cache.set(key, schema);
+        cache.set(key, options.inlineRefs ? inlineRefs(schema) : schema);
     }
     return cache.get(key);
 }

package/lib/esm/index.js

@@ -199,6 +199,7 @@ export * from "./utils/getJsonType.js";
 export * from "./utils/getOperationsRoutes.js";
 export * from "./utils/getOperationsStores.js";
 export * from "./utils/getPropertiesStores.js";
+export * from "./utils/inlineRefs.js";
 export * from "./utils/isSuccessStatus.js";
 export * from "./utils/mapHeaders.js";
 export * from "./utils/mapOperationOptions.js";

package/lib/esm/utils/inlineRefs.js

@@ -0,0 +1,64 @@
+import { isPlainObject } from "@tsed/core";
+import { mergeSchema } from "./mergeSchema.js";
+function getLocalReference(schema, $ref) {
+    if (!$ref.startsWith("#/")) {
+        return;
+    }
+    return $ref
+        .slice(2)
+        .split("/")
+        .map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"))
+        .reduce((value, segment) => value?.[segment], schema);
+}
+function inline(value, root, resolving) {
+    if (Array.isArray(value)) {
+        return value.map((item) => inline(item, root, resolving));
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const { $ref, ...siblings } = value;
+    const target = typeof $ref === "string" && !resolving.has($ref) ? getLocalReference(root, $ref) : undefined;
+    if (target) {
+        const nextResolving = new Set(resolving).add($ref);
+        return {
+            ...inline(target, root, nextResolving),
+            ...inline(siblings, root, resolving)
+        };
+    }
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, inline(item, root, resolving)]));
+}
+function flattenAllOf(value) {
+    if (Array.isArray(value)) {
+        return value.map(flattenAllOf);
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const schema = Object.fromEntries(Object.entries(value).map(([key, item]) => [key, flattenAllOf(item)]));
+    if (!Array.isArray(schema.allOf)) {
+        return schema;
+    }
+    const { allOf, ...rest } = schema;
+    return allOf.reduce((merged, item) => mergeSchema(merged, item), rest);
+}
+function hasLocalRefs(value) {
+    if (Array.isArray(value)) {
+        return value.some(hasLocalRefs);
+    }
+    if (!isPlainObject(value)) {
+        return false;
+    }
+    return (typeof value.$ref === "string" && value.$ref.startsWith("#/")) || Object.values(value).some(hasLocalRefs);
+}
+/**
+ * Returns a copy of a JSON Schema with resolvable local references inlined.
+ * Circular and external references are preserved.
+ *
+ * @ignore
+ */
+export function inlineRefs(schema) {
+    const inlined = flattenAllOf(inline(schema, schema, new Set()));
+    const { definitions, ...result } = inlined;
+    return hasLocalRefs(result) ? inlined : result;
+}

package/lib/types/domain/JsonSchemaOptions.d.ts

@@ -60,6 +60,12 @@ export interface JsonSchemaOptions {
      * Inline enums when enum instead of using $ref.
      */
     inlineEnums?: boolean;
+    /**
+     * Inline resolvable local JSON Schema references in the compiled output.
+     *
+     * External references and circular local references are preserved.
+     */
+    inlineRefs?: boolean;
     /**
      * Explicit generic bindings used during schema compilation.
      *

package/lib/types/fn/compile.d.ts

@@ -12,7 +12,7 @@ import { JsonSchemaOptions } from "../domain/JsonSchemaOptions.js";
  * @param options JSON schema generation options.
  * @returns Compiled JSON schema object.
  */
-export declare function compile(model: Type<any> | JsonParameterStore | JsonSchema, options?: JsonSchemaOptions): any;
+export declare function compile(model: Type<any> | JsonParameterStore | JsonSchema<any>, options?: JsonSchemaOptions): any;
 /**
  * @deprecated Use s.compile() instead
  * @param model

package/lib/types/index.d.ts

@@ -199,6 +199,7 @@ export * from "./utils/getJsonType.js";
 export * from "./utils/getOperationsRoutes.js";
 export * from "./utils/getOperationsStores.js";
 export * from "./utils/getPropertiesStores.js";
+export * from "./utils/inlineRefs.js";
 export * from "./utils/isSuccessStatus.js";
 export * from "./utils/mapHeaders.js";
 export * from "./utils/mapOperationOptions.js";

package/lib/types/utils/inlineRefs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns a copy of a JSON Schema with resolvable local references inlined.
+ * Circular and external references are preserved.
+ *
+ * @ignore
+ */
+export declare function inlineRefs(schema: Record<string, any>): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/schema",
-  "version": "8.35.0",
+  "version": "8.36.0",
   "description": "JsonSchema module for Ts.ED Framework",
   "keywords": [
     "JsonSchema",
@@ -34,7 +34,7 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/openspec": "8.35.0",
+    "@tsed/openspec": "8.36.0",
     "change-case": "^5.4.4",
     "json-schema": "0.4.0",
     "picomatch": "4.0.4",
@@ -43,11 +43,11 @@
   },
   "devDependencies": {
     "@apidevtools/swagger-parser": "10.1.0",
-    "@tsed/barrels": "8.35.0",
-    "@tsed/core": "8.35.0",
-    "@tsed/hooks": "8.35.0",
-    "@tsed/openspec": "8.35.0",
-    "@tsed/typescript": "8.35.0",
+    "@tsed/barrels": "8.36.0",
+    "@tsed/core": "8.36.0",
+    "@tsed/hooks": "8.36.0",
+    "@tsed/openspec": "8.36.0",
+    "@tsed/typescript": "8.36.0",
     "@types/fs-extra": "11.0.4",
     "@types/json-schema": "7.0.15",
     "@types/picomatch": "3.0.2",