@takeshape/json-schema 11.105.1 → 11.107.1

package/dist/converters/schema-converter.js

@@ -1,7 +1,7 @@
 import { assert, ensureArray } from '@takeshape/util';
 import intersection from 'lodash/intersection.js';
 import uniq from 'lodash/uniq.js';
-import { getReferenceMap, isAllOfSchema, isAnyOfSchema, isArraySchema, isEnumSchema, isListSchema, isObjectSchema, isOneOfSchema, isPropertySchema, isRefSchema, isTupleSchema, pickJSONSchema7 } from "../utils/index.js";
+import { getReferenceMap, isAllOfSchema, isAnyOfSchema, isArraySchema, isEnumSchema, isListSchema, isObjectSchema, isObjectSchemaWithProperties, isOneOfSchema, isRefSchema, isTupleSchema, pickJSONSchema7 } from "../utils/index.js";
 export var SchemaConversionTarget;
 (function (SchemaConversionTarget) {
     SchemaConversionTarget["OpenAI"] = "OPENAI";
@@ -74,7 +74,7 @@ export class SchemaConverter {
             this.warnings.push(`Schema has ${this.stats.enumValuesCount} enum values across all properties, exceeding the 500 limit`);
         }
         // Check if root is an object
-        if (target === SchemaConversionTarget.OpenAI && !isPropertySchema(result)) {
+        if (target === SchemaConversionTarget.OpenAI && !isObjectSchemaWithProperties(result)) {
             this.warnings.push('Root level must be an object type, wrapping in an object');
             // Attempt to fix by wrapping in an object if possible
             return {
@@ -116,7 +116,7 @@ export class SchemaConverter {
             return this.processRefSchema(context, schemaCopy);
         }
         // Process specific types
-        if (isObjectSchema(schemaCopy) || isPropertySchema(schemaCopy)) {
+        if (isObjectSchema(schemaCopy)) {
             return this.addNullable(this.processObjectSchema(context, schemaCopy), isRequired);
         }
         if (isArraySchema(schemaCopy)) {
@@ -419,7 +419,7 @@ export class SchemaConverter {
         // Try to merge properties from all schemas
         for (const [index, value] of allOfSchemas.entries()) {
             const subSchema = this.processSchema({ ...context, path: [...path, 'allOf', index] }, value);
-            if (isObjectSchema(subSchema) && isPropertySchema(subSchema)) {
+            if (isObjectSchemaWithProperties(subSchema)) {
                 // Merge properties
                 newSchema.properties = {
                     ...newSchema.properties,

package/dist/utils/references.d.ts

@@ -1,5 +1,145 @@
-import type { JSONSchema7Definition } from 'json-schema';
+import type { JSONSchema7, JSONSchema7Definition } from 'json-schema';
+export declare function getDefinitionKey(ref: string): string;
 /**
  * Get all the definitions that are referenced by other definitions.
  */
 export declare function getReferenceMap(definitions: Record<string, JSONSchema7Definition>): Map<string, Set<string>>;
+/**
+ * Prunes the schema definitions to only include those that are referenced either directly
+ * or indirectly by the specified root reference.
+ *
+ * @param {JSONSchema7} schema - The JSON schema object containing the definitions to prune.
+ * @param {string} ref - The reference identifier that serves as the root for pruning definitions.
+ * @return {JSONSchema7} - A new JSON schema object with pruned definitions.
+ */
+export declare function pruneSchemaDefinitions(schema: JSONSchema7, ref: string): {
+    definitions: Record<string, JSONSchema7Definition>;
+    $id?: string | undefined;
+    $ref?: string | undefined;
+    $schema?: import("json-schema").JSONSchema7Version | undefined;
+    $comment?: string | undefined;
+    $defs?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    type?: import("json-schema").JSONSchema7TypeName | import("json-schema").JSONSchema7TypeName[] | undefined;
+    enum?: import("json-schema").JSONSchema7Type[] | undefined;
+    const?: import("json-schema").JSONSchema7Type | undefined;
+    multipleOf?: number | undefined;
+    maximum?: number | undefined;
+    exclusiveMaximum?: number | undefined;
+    minimum?: number | undefined;
+    exclusiveMinimum?: number | undefined;
+    maxLength?: number | undefined;
+    minLength?: number | undefined;
+    pattern?: string | undefined;
+    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+    additionalItems?: JSONSchema7Definition | undefined;
+    maxItems?: number | undefined;
+    minItems?: number | undefined;
+    uniqueItems?: boolean | undefined;
+    contains?: JSONSchema7Definition | undefined;
+    maxProperties?: number | undefined;
+    minProperties?: number | undefined;
+    required?: string[] | undefined;
+    properties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    patternProperties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined;
+    additionalProperties?: JSONSchema7Definition | undefined;
+    dependencies?: {
+        [key: string]: JSONSchema7Definition | string[];
+    } | undefined;
+    propertyNames?: JSONSchema7Definition | undefined;
+    if?: JSONSchema7Definition | undefined;
+    then?: JSONSchema7Definition | undefined;
+    else?: JSONSchema7Definition | undefined;
+    allOf?: JSONSchema7Definition[] | undefined;
+    anyOf?: JSONSchema7Definition[] | undefined;
+    oneOf?: JSONSchema7Definition[] | undefined;
+    not?: JSONSchema7Definition | undefined;
+    format?: string | undefined;
+    contentMediaType?: string | undefined;
+    contentEncoding?: string | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    default?: import("json-schema").JSONSchema7Type | undefined;
+    readOnly?: boolean | undefined;
+    writeOnly?: boolean | undefined;
+    examples?: import("json-schema").JSONSchema7Type | undefined;
+    discriminator?: {
+        propertyName: string;
+    };
+};
+/**
+ * Promotes a specific object schema definition within a JSON Schema, potentially simplifying the schema
+ * by focusing on the desired object and pruning unused definitions.
+ *
+ * Note this does not support promoting schemas that are self-referential
+ *
+ * @param {JSONSchema7} schema - The full JSON Schema to process.
+ * @param {string} ref - The reference string identifying the target object schema within the definitions.
+ * @return {ObjectSchemaWithProperties} The promoted object schema along with pruned definitions.
+ * @throws {Error} If the specified reference does not correspond to a valid object definition within the schema.
+ */
+export declare function promoteObjectSchema(schema: JSONSchema7, ref: string): {
+    definitions: {
+        [x: string]: JSONSchema7Definition;
+    };
+    minimum?: number | undefined | undefined;
+    maximum?: number | undefined | undefined;
+    exclusiveMinimum?: number | undefined | undefined;
+    exclusiveMaximum?: number | undefined | undefined;
+    multipleOf?: number | undefined | undefined;
+    format?: string | undefined | undefined;
+    allOf?: JSONSchema7Definition[] | undefined | undefined;
+    anyOf?: JSONSchema7Definition[] | undefined | undefined;
+    oneOf?: JSONSchema7Definition[] | undefined | undefined;
+    if?: JSONSchema7Definition | undefined;
+    then?: JSONSchema7Definition | undefined;
+    else?: JSONSchema7Definition | undefined;
+    not?: JSONSchema7Definition | undefined;
+    $id?: string | undefined | undefined;
+    $ref?: string | undefined | undefined;
+    $defs?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined | undefined;
+    $schema?: string | undefined;
+    $comment?: string | undefined | undefined;
+    type: "object";
+    enum?: import("json-schema").JSONSchema7Type[] | undefined | undefined;
+    const?: import("json-schema").JSONSchema7Type | undefined;
+    maxLength?: number | undefined | undefined;
+    minLength?: number | undefined | undefined;
+    pattern?: string | undefined | undefined;
+    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
+    additionalItems?: JSONSchema7Definition | undefined;
+    maxItems?: number | undefined | undefined;
+    minItems?: number | undefined | undefined;
+    uniqueItems?: boolean | undefined | undefined;
+    contains?: JSONSchema7Definition | undefined;
+    maxProperties?: number | undefined | undefined;
+    minProperties?: number | undefined | undefined;
+    required?: string[] | undefined | undefined;
+    patternProperties?: {
+        [key: string]: JSONSchema7Definition;
+    } | undefined | undefined;
+    additionalProperties?: JSONSchema7Definition | undefined;
+    dependencies?: {
+        [key: string]: JSONSchema7Definition | string[];
+    } | undefined | undefined;
+    propertyNames?: JSONSchema7Definition | undefined;
+    contentMediaType?: string | undefined | undefined;
+    contentEncoding?: string | undefined | undefined;
+    title?: string | undefined | undefined;
+    description?: string | undefined | undefined;
+    default?: import("json-schema").JSONSchema7Type | undefined;
+    readOnly?: boolean | undefined | undefined;
+    writeOnly?: boolean | undefined | undefined;
+    examples?: import("json-schema").JSONSchema7Type | undefined;
+    discriminator?: {
+        propertyName: string;
+    } | undefined;
+    properties: Exclude<JSONSchema7["properties"], undefined>;
+};

package/dist/utils/references.js

@@ -1,47 +1,21 @@
-import { isAllOfSchema, isAnyOfSchema, isOneOfSchema, isPropertySchema, isRefSchema, isSchema } from "./type-utils.js";
-const SCHEMA_DEFINITION_PREFIX = ['#/definitions/', '#/$defs/'];
-function collectRef(def, key, collect) {
-    if (isRefSchema(def)) {
-        collect(def.$ref, key);
-    }
-    else if (isSchema(def)) {
-        collectRefs(def, key, collect);
-    }
-}
+import { visit } from '@takeshape/util';
+import { isObjectSchemaWithProperties, isSchema } from "./type-utils.js";
 function collectRefs(def, key, collect) {
-    if (isPropertySchema(def)) {
-        for (const d of Object.values(def.properties)) {
-            collectRef(d, key, collect);
-        }
-    }
-    else if (isAllOfSchema(def)) {
-        for (const d of def.allOf) {
-            collectRef(d, key, collect);
-        }
-    }
-    else if (isAnyOfSchema(def)) {
-        for (const d of def.anyOf) {
-            collectRef(d, key, collect);
-        }
+    if (!isSchema(def)) {
+        return;
     }
-    else if (isOneOfSchema(def)) {
-        for (const d of def.oneOf) {
-            collectRef(d, key, collect);
+    visit(def, ['$ref'], ($ref) => {
+        if ($ref && typeof $ref === 'string') {
+            collect($ref, key);
         }
+    });
+}
+export function getDefinitionKey(ref) {
+    const [, prefix, name] = ref.split('/');
+    if (!name || (prefix !== 'definitions' && prefix !== '$defs')) {
+        throw new Error(`Invalid reference: ${ref}`);
     }
-    else if (Array.isArray(def.items)) {
-        for (const d of def.items) {
-            collectRef(d, key, collect);
-        }
-    }
-    else if (def.items) {
-        if (isSchema(def.items) && isRefSchema(def.items)) {
-            collect(def.items.$ref, key);
-        }
-    }
-    else if (isRefSchema(def)) {
-        collect(def.$ref, key);
-    }
+    return name;
 }
 /**
  * Get all the definitions that are referenced by other definitions.
@@ -50,7 +24,7 @@ export function getReferenceMap(definitions) {
     const references = new Map();
     const visited = new Set();
     const addToReferenceMap = (ref, key) => {
-        const refKey = ref.replace(SCHEMA_DEFINITION_PREFIX[0], '').replace(SCHEMA_DEFINITION_PREFIX[1], '');
+        const refKey = getDefinitionKey(ref);
         // Circular reference
         if (key === refKey) {
             return;
@@ -74,3 +48,66 @@ export function getReferenceMap(definitions) {
     }
     return references;
 }
+/**
+ * Prunes the schema definitions to only include those that are referenced either directly
+ * or indirectly by the specified root reference.
+ *
+ * @param {JSONSchema7} schema - The JSON schema object containing the definitions to prune.
+ * @param {string} ref - The reference identifier that serves as the root for pruning definitions.
+ * @return {JSONSchema7} - A new JSON schema object with pruned definitions.
+ */
+export function pruneSchemaDefinitions(schema, ref) {
+    if (!schema.definitions) {
+        throw new Error('Schema does not have definitions');
+    }
+    const references = new Set();
+    const visited = new Set();
+    const addToReferences = (ref) => {
+        const definitionKey = getDefinitionKey(ref);
+        if (visited.has(definitionKey)) {
+            return;
+        }
+        visited.add(definitionKey);
+        references.add(definitionKey);
+        const refDef = schema.definitions?.[definitionKey];
+        if (refDef && isSchema(refDef)) {
+            collectRefs(refDef, definitionKey, addToReferences);
+        }
+    };
+    addToReferences(ref);
+    const newDefinitions = {};
+    for (const ref of references) {
+        const def = schema.definitions?.[ref];
+        if (def) {
+            newDefinitions[ref] = def;
+        }
+    }
+    return {
+        ...schema,
+        definitions: newDefinitions
+    };
+}
+/**
+ * Promotes a specific object schema definition within a JSON Schema, potentially simplifying the schema
+ * by focusing on the desired object and pruning unused definitions.
+ *
+ * Note this does not support promoting schemas that are self-referential
+ *
+ * @param {JSONSchema7} schema - The full JSON Schema to process.
+ * @param {string} ref - The reference string identifying the target object schema within the definitions.
+ * @return {ObjectSchemaWithProperties} The promoted object schema along with pruned definitions.
+ * @throws {Error} If the specified reference does not correspond to a valid object definition within the schema.
+ */
+export function promoteObjectSchema(schema, ref) {
+    const key = getDefinitionKey(ref);
+    const definition = schema.definitions?.[key];
+    if (!definition || !isObjectSchemaWithProperties(definition)) {
+        throw new Error(`Could not find object definition for ${ref}`);
+    }
+    const prunedSchema = pruneSchemaDefinitions(schema, ref);
+    const { [key]: _, ...rest } = prunedSchema.definitions;
+    return {
+        ...definition,
+        definitions: rest
+    };
+}

package/dist/utils/type-utils.d.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema7Definition } from 'json-schema';
-import type { AllOfSchema, AnyOfSchema, ArraySchema, ConstSchema, EnumSchema, ListSchema, ObjectSchema, OneOfSchema, PrimitiveSchema, PropertySchema, RefSchema, TupleSchema, TypeUnionSchema } from './types.ts';
+import type { AllOfSchema, AnyOfSchema, ArraySchema, ConstSchema, EnumSchema, ListSchema, ObjectSchema, ObjectSchemaWithProperties, OneOfSchema, PrimitiveSchema, RefSchema, TupleSchema, TypeUnionSchema } from './types.ts';
 export declare function isBooleanProperty(schema: JSONSchema7Definition): schema is boolean;
 export declare function isSchema(schema: JSONSchema7Definition): schema is Exclude<JSONSchema7Definition, boolean>;
 export declare function isOneOfSchema(schema: JSONSchema7Definition): schema is OneOfSchema;
@@ -7,7 +7,7 @@ export declare function isAnyOfSchema(schema: JSONSchema7Definition): schema is
 export declare function isAllOfSchema(schema: JSONSchema7Definition): schema is AllOfSchema;
 export declare function isUnionSchema(schema: JSONSchema7Definition): schema is OneOfSchema | AnyOfSchema | AllOfSchema;
 export declare function isObjectSchema(schema: JSONSchema7Definition): schema is ObjectSchema;
-export declare function isPropertySchema(schema: JSONSchema7Definition): schema is PropertySchema;
+export declare function isObjectSchemaWithProperties(schema: JSONSchema7Definition): schema is ObjectSchemaWithProperties;
 export declare function isArraySchema(schema: JSONSchema7Definition): schema is ArraySchema;
 export declare function isListSchema(schema: JSONSchema7Definition): schema is ListSchema;
 export declare function isTupleSchema(schema: JSONSchema7Definition): schema is TupleSchema;

package/dist/utils/type-utils.js

@@ -20,7 +20,7 @@ export function isUnionSchema(schema) {
 export function isObjectSchema(schema) {
     return isSchema(schema) && schema.type === 'object';
 }
-export function isPropertySchema(schema) {
+export function isObjectSchemaWithProperties(schema) {
     return isObjectSchema(schema) && typeof schema.properties === 'object';
 }
 export function isArraySchema(schema) {

package/dist/utils/types.d.ts

@@ -22,7 +22,7 @@ export type AllOfSchema = Omit<JSONSchema7, 'allOf'> & {
 export type ObjectSchema = Omit<JSONSchema7, 'type'> & {
     type: 'object';
 };
-export type PropertySchema = Omit<ObjectSchema, 'properties'> & {
+export type ObjectSchemaWithProperties = Omit<ObjectSchema, 'properties'> & {
     properties: Exclude<JSONSchema7['properties'], undefined>;
 };
 export type ArraySchema = Omit<JSONSchema7, 'type'> & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takeshape/json-schema",
-  "version": "11.105.1",
+  "version": "11.107.1",
   "description": "JSON Schema validator",
   "homepage": "https://www.takeshape.io",
   "repository": {
@@ -37,13 +37,13 @@
     "ajv": "8.13.0",
     "ajv-formats": "3.0.1",
     "lodash": "4.17.21",
-    "minimatch": "^3.0.4",
-    "@takeshape/util": "11.105.1"
+    "minimatch": "3.1.2",
+    "@takeshape/util": "11.107.1"
   },
   "devDependencies": {
-    "@types/json-schema": "^7.0.7",
+    "@types/json-schema": "7.0.15",
     "@types/lodash": "4.17.20",
-    "@types/minimatch": "^3.0.3"
+    "@types/minimatch": "3.0.5"
   },
   "engines": {
     "node": ">=22"