@orpc/json-schema 2.0.0-beta.47 → 2.0.0-beta.48

package/dist/composition-utils.mjs

@@ -0,0 +1,357 @@
+import { get, isDeepEqual, omit, toArray } from "@orpc/shared";
+import { JSON_SCHEMA_LOGIC_KEYWORDS } from "./constants.mjs";
+import { decodeJsonPointerSegment, encodeJsonPointerSegment, hoistRecursiveRefToDef, mapJsonSchemaRefs, resolveJsonSchemaRootLocalRef } from "./ref-utils.mjs";
+import { ensureJsonSchemaObject, isJsonArraySchema, isUnconstrainedSchema } from "./utils.mjs";
+
+function promoteJsonSchemaDefs(schema, mergedDefs, basePath) {
+	const { $defs, ...rootBody } = schema;
+	const renameMap = new Map();
+	
+	const mapRef = (ref) => {
+		if (ref === "#") {
+			return basePath;
+		}
+		if (ref.startsWith("#/$defs/")) {
+			const [encodedName, ...segments] = ref.slice("#/$defs/".length).split("/");
+			const newName = renameMap.get(decodeJsonPointerSegment(encodedName));
+			return newName === undefined ? ref : [
+				"#/$defs",
+				encodeJsonPointerSegment(newName),
+				...segments
+			].join("/");
+		}
+		if (ref.startsWith("#/") && get(rootBody, ref.slice(2).split("/").map(decodeJsonPointerSegment)) !== undefined) {
+			return `${basePath}/${ref.slice(2)}`;
+		}
+		return ref;
+	};
+	const defs = Object.entries($defs ?? {}).filter(([, def]) => def !== undefined);
+	if (defs.length > 0) {
+		const promoted = new Map();
+		const reserved = new Set([...mergedDefs.keys(), ...defs.map(([name]) => name)]);
+		
+		for (let changed = true; changed;) {
+			changed = false;
+			for (const [name, def] of defs) {
+				const body = mapJsonSchemaRefs(def, mapRef);
+				promoted.set(name, body);
+				if (renameMap.has(name) || !mergedDefs.has(name) || isDeepEqual(mergedDefs.get(name), body)) {
+					continue;
+				}
+				let counter = 2;
+				while (reserved.has(`${name}${counter}`)) {
+					counter++;
+				}
+				reserved.add(`${name}${counter}`);
+				renameMap.set(name, `${name}${counter}`);
+				changed = true;
+			}
+		}
+		for (const [name, body] of promoted) {
+			mergedDefs.set(renameMap.get(name) ?? name, body);
+		}
+	}
+	return mapJsonSchemaRefs(rootBody, mapRef);
+}
+
+export function combineJsonSchemasWithComposition(keyword, schemas) {
+	if (schemas.length <= 1) {
+		return schemas[0] ?? true;
+	}
+	const mergedDefs = new Map();
+	const compositionBranches = [];
+	for (let i = 0; i < schemas.length; i++) {
+		const schema = schemas[i];
+		compositionBranches.push(typeof schema === "boolean" ? schema : promoteJsonSchemaDefs(schema, mergedDefs, `#/${keyword}/${i}`));
+	}
+	const result = { [keyword]: compositionBranches };
+	if (mergedDefs.size > 0) {
+		result.$defs = Object.fromEntries(mergedDefs);
+	}
+	return result;
+}
+
+export function combineJsonObjectSchemaEntries(entries, additionalProperties) {
+	const properties = new Map();
+	const required = [];
+	const mergedDefs = new Map();
+	for (const [name, propertySchema, optional] of entries) {
+		if (!optional) {
+			required.push(name);
+		}
+		properties.set(name, typeof propertySchema === "boolean" ? propertySchema : promoteJsonSchemaDefs(propertySchema, mergedDefs, `#/properties/${encodeJsonPointerSegment(name)}`));
+	}
+	const schema = {
+		type: "object",
+		properties: Object.fromEntries(properties)
+	};
+	if (required.length > 0) {
+		schema.required = required;
+	}
+	if (additionalProperties !== undefined) {
+		schema.additionalProperties = typeof additionalProperties === "boolean" ? additionalProperties : promoteJsonSchemaDefs(additionalProperties, mergedDefs, "#/additionalProperties");
+	}
+	if (mergedDefs.size > 0) {
+		schema.$defs = Object.fromEntries(mergedDefs);
+	}
+	return schema;
+}
+
+export function extractJsonObjectSchemaEntries(schema) {
+	schema = hoistRecursiveRefToDef(schema);
+	if (typeof schema !== "object") {
+		return undefined;
+	}
+	const result = extractJsonObjectSchemaEntriesInternal(omit(schema, ["$defs"]), schema.$defs, new Set());
+	if (!result.objectLike) {
+		return undefined;
+	}
+	return result.entries.map(([n, s, ...r]) => [
+		n,
+		withRootDefs(s, schema.$defs),
+		...r
+	]);
+}
+
+export function extractJsonObjectSchemaAdditionalProperties(schema) {
+	schema = hoistRecursiveRefToDef(schema);
+	if (typeof schema !== "object") {
+		return undefined;
+	}
+	const resolved = resolveJsonSchemaRootLocalRef(schema);
+	if (typeof resolved !== "object" || resolved.additionalProperties === undefined) {
+		return undefined;
+	}
+	return withRootDefs(resolved.additionalProperties, schema.$defs);
+}
+const JSON_SCHEMA_OBJECT_KEYWORDS = [
+	"properties",
+	"patternProperties",
+	"additionalProperties",
+	"required",
+	"propertyNames",
+	"minProperties",
+	"maxProperties"
+];
+
+export function isJsonObjectLikeSchema(schema) {
+	return isJsonObjectLikeSchemaInternal(schema, typeof schema === "object" ? schema.$defs : undefined, new Set());
+}
+function isJsonObjectLikeSchemaInternal(schema, $defs, followedRefs) {
+	if (typeof schema === "object" && typeof schema.$ref === "string") {
+		
+		if (followedRefs.has(schema.$ref)) {
+			return false;
+		}
+		followedRefs = new Set(followedRefs).add(schema.$ref);
+	}
+	const resolved = resolveJsonSchemaRootLocalRef(schema, $defs);
+	if (typeof resolved === "boolean") {
+		return true;
+	}
+	if (resolved.type !== undefined) {
+		return resolved.type === "object";
+	}
+	if (JSON_SCHEMA_OBJECT_KEYWORDS.some((keyword) => keyword in resolved)) {
+		return true;
+	}
+	for (const keyword of [
+		"allOf",
+		"anyOf",
+		"oneOf"
+	]) {
+		const members = resolved[keyword];
+		if (Array.isArray(members) && members.length > 0) {
+			return members.every((member) => isJsonObjectLikeSchemaInternal(member, $defs, followedRefs));
+		}
+	}
+	return isUnconstrainedSchema(resolved);
+}
+function extractJsonObjectSchemaEntriesInternal(schema, $defs, resolvingRefs) {
+	if (typeof schema !== "object") {
+		return {
+			entries: [],
+			objectLike: false
+		};
+	}
+	if (typeof schema.$ref === "string") {
+		if (resolvingRefs.has(schema.$ref)) {
+			return {
+				entries: [],
+				objectLike: true
+			};
+		}
+		const resolved = resolveJsonSchemaRootLocalRef(schema, $defs);
+		if (resolved !== schema) {
+			return extractJsonObjectSchemaEntriesInternal(resolved, $defs, new Set(resolvingRefs).add(schema.$ref));
+		}
+	}
+	const sources = [];
+	if (schema.properties) {
+		sources.push({
+			entries: Object.entries(schema.properties).map(([name, propertySchema]) => {
+				return [
+					name,
+					propertySchema,
+					!schema.required?.includes(name)
+				];
+			}),
+			source: "direct"
+		});
+	}
+	let objectLike = schema.type === "object" || schema.properties !== undefined || schema.required !== undefined || schema.additionalProperties !== undefined;
+	for (const keyword of [
+		"anyOf",
+		"oneOf",
+		"allOf"
+	]) {
+		const branches = schema[keyword];
+		if (branches === undefined) {
+			continue;
+		}
+		const branchResults = branches.map((branch) => extractJsonObjectSchemaEntriesInternal(branch, $defs, resolvingRefs));
+		if (branchResults.some((result) => !result.objectLike)) {
+			return {
+				entries: [],
+				objectLike: false
+			};
+		}
+		const entriesByName = new Map();
+		for (const result of branchResults) {
+			for (const entry of result.entries) {
+				const entries = entriesByName.get(entry[0]);
+				if (entries) {
+					entries.push(entry);
+				} else {
+					entriesByName.set(entry[0], [entry]);
+				}
+			}
+		}
+		objectLike = true;
+		sources.push({
+			entries: Array.from(entriesByName.entries()).map(([name, entries]) => {
+				const schemas = deduplicateJsonSchemas(entries.map((entry) => entry[1]));
+				const required = keyword === "allOf" ? entries.some((entry) => !entry[2]) : branchResults.every((result) => {
+					const entry = result.entries.find((item) => item[0] === name);
+					return entry !== undefined && !entry[2];
+				});
+				return [
+					name,
+					schemas.length === 1 ? schemas[0] : keyword === "allOf" ? { allOf: schemas } : { anyOf: schemas },
+					!required
+				];
+			}),
+			source: keyword
+		});
+	}
+	const sourceEntries = new Map();
+	for (const { entries, source } of sources) {
+		for (const entry of entries) {
+			const existing = sourceEntries.get(entry[0]);
+			if (existing) {
+				existing[source] = entry;
+			} else {
+				sourceEntries.set(entry[0], { [source]: entry });
+			}
+		}
+	}
+	return {
+		entries: Array.from(sourceEntries.entries()).map(([name, entries]) => {
+			const schemas = deduplicateJsonSchemas([
+				entries.direct?.[1],
+				entries.allOf?.[1],
+				entries.anyOf?.[1],
+				entries.oneOf?.[1]
+			].filter((schema) => schema !== undefined));
+			return [
+				name,
+				schemas.length === 1 ? schemas[0] : { allOf: schemas },
+				!schema.required?.includes(name) && [
+					entries.allOf,
+					entries.anyOf,
+					entries.oneOf
+				].every((entry) => entry === undefined || entry[2])
+			];
+		}),
+		objectLike
+	};
+}
+
+export function flattenJsonUnionSchema(schema) {
+	return deduplicateJsonSchemas(flattenJsonUnionSchemaInternal(schema, new Set()));
+}
+function flattenJsonUnionSchemaInternal(schema, resolvingRefs) {
+	if (typeof schema !== "object") {
+		return [schema];
+	}
+	if (typeof schema.$ref === "string") {
+		if (resolvingRefs.has(schema.$ref)) {
+			return [];
+		}
+		const resolved = resolveJsonSchemaRootLocalRef(schema);
+		if (resolved !== schema) {
+			const result = flattenJsonUnionSchemaInternal(resolved, new Set(resolvingRefs).add(schema.$ref));
+			if (result.length > 1) {
+				return result;
+			}
+		}
+	}
+	const { anyOf: _anyOf, oneOf: _oneOf, ...rest } = schema;
+	const entries = Object.entries(rest).filter(([, val]) => val !== undefined);
+	for (const keyword of ["anyOf", "oneOf"]) {
+		if (schema[keyword]) {
+			return schema[keyword].flatMap((s) => {
+				s = ensureJsonSchemaObject(s);
+				const mergedSchema = {
+					...s,
+					...Object.fromEntries(entries.filter(([key]) => s[key] === undefined)),
+					$defs: schema.$defs
+				};
+				const conflicts = entries.filter(([key]) => s[key] !== undefined);
+				if (conflicts.length) {
+					mergedSchema.allOf = [...toArray(mergedSchema.allOf), Object.fromEntries(conflicts)];
+				}
+				return flattenJsonUnionSchemaInternal(mergedSchema, resolvingRefs);
+			});
+		}
+	}
+	return [schema];
+}
+
+export function matchArrayableJsonSchema(schema) {
+	const schemas = flattenJsonUnionSchema(schema);
+	if (schemas.length !== 2) {
+		return undefined;
+	}
+	const arraySchema = schemas.find(isJsonArraySchema);
+	if (arraySchema === undefined) {
+		return undefined;
+	}
+	const items1 = arraySchema.items ?? true;
+	const items2 = schemas.find((s) => s !== arraySchema);
+	const logicItem1 = Object.fromEntries(Object.entries(ensureJsonSchemaObject(items1)).filter(([key]) => JSON_SCHEMA_LOGIC_KEYWORDS.has(key)));
+	const logicItem2 = Object.fromEntries(Object.entries(ensureJsonSchemaObject(items2)).filter(([key]) => JSON_SCHEMA_LOGIC_KEYWORDS.has(key)));
+	if (!isDeepEqual(logicItem1, logicItem2)) {
+		return undefined;
+	}
+	return [items2, arraySchema];
+}
+export function deduplicateJsonSchemas(schemas) {
+	const result = [];
+	for (const schema of schemas) {
+		if (result.some((i) => isDeepEqual(i, schema))) {
+			continue;
+		}
+		result.push(schema);
+	}
+	return result;
+}
+function withRootDefs(schema, $defs) {
+	if (typeof schema === "boolean" || !$defs) {
+		return schema;
+	}
+	return {
+		...schema,
+		$defs
+	};
+}

package/dist/constants.d.mts

@@ -0,0 +1,4 @@
+import type { JsonSchemaKeywords } from "./types.mjs";
+export declare const JSON_SCHEMA_LOGIC_KEYWORDS: Set<JsonSchemaKeywords | string & {}>;
+export declare const JSON_SCHEMA_PRIMITIVE_TYPES: Set<string>;
+export declare const JSON_SCHEMA_RECORD_KEYWORDS: Set<string>;

package/dist/constants.mjs

@@ -0,0 +1,61 @@
+export const JSON_SCHEMA_LOGIC_KEYWORDS = /* @__PURE__ */ new Set([
+	"$dynamicRef",
+	"$ref",
+	"additionalItems",
+	"additionalProperties",
+	"allOf",
+	"anyOf",
+	"const",
+	"contains",
+	"contentEncoding",
+	"contentMediaType",
+	"contentSchema",
+	"dependencies",
+	"dependentRequired",
+	"dependentSchemas",
+	"else",
+	"enum",
+	"exclusiveMaximum",
+	"exclusiveMinimum",
+	"format",
+	"if",
+	"items",
+	"maxContains",
+	"maximum",
+	"maxItems",
+	"maxLength",
+	"maxProperties",
+	"minContains",
+	"minimum",
+	"minItems",
+	"minLength",
+	"minProperties",
+	"multipleOf",
+	"not",
+	"oneOf",
+	"pattern",
+	"patternProperties",
+	"prefixItems",
+	"properties",
+	"propertyNames",
+	"required",
+	"then",
+	"type",
+	"unevaluatedItems",
+	"unevaluatedProperties",
+	"uniqueItems"
+]);
+export const JSON_SCHEMA_PRIMITIVE_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"number",
+	"integer",
+	"boolean",
+	"null"
+]);
+export const JSON_SCHEMA_RECORD_KEYWORDS = /* @__PURE__ */ new Set([
+	"properties",
+	"patternProperties",
+	"dependentSchemas",
+	"dependencies",
+	"$defs"
+]);

package/dist/convert.d.mts

@@ -0,0 +1,29 @@
+import type { AnySchema } from "@orpc/contract";
+import type { JsonSchema } from "./types.mjs";
+/**
+* The conversion direction: `input` targets the schema's input type, `output` targets its output type.
+*
+* @see {@link https://orpc.dev/docs/integrations/standard-schema | Standard Schema Integration}
+*/
+export type JsonSchemaConverterDirection = "input" | "output";
+/**
+* Interface for converting validation schemas into JSON Schema representations,
+* used by tools such as the OpenAPI Generator and Smart Coercion plugins.
+*
+* @see {@link https://orpc.dev/docs/integrations/standard-schema | Standard Schema Integration}
+*/
+export interface JsonSchemaConverter {
+	/**
+	* Determines whether this converter can handle the given schema.
+	*/
+	condition(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): boolean;
+	/**
+	* Converts an ORPC schema to a JSON Schema representation.
+	*/
+	convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
+}
+export declare class DelegatingJsonSchemaConverter implements Pick<JsonSchemaConverter, "convert"> {
+	private readonly converters;
+	constructor(converters?: JsonSchemaConverter[]);
+	convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
+}

package/dist/convert.mjs

@@ -0,0 +1,14 @@
+export class DelegatingJsonSchemaConverter {
+	converters;
+	constructor(converters = []) {
+		this.converters = converters;
+	}
+	convert(schema, direction) {
+		for (const converter of this.converters) {
+			if (converter.condition(schema, direction)) {
+				return converter.convert(schema, direction);
+			}
+		}
+		return [{}, true];
+	}
+}