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

package/README.md

@@ -191,15 +191,14 @@ Like what we build over at [middleapi](https://github.com/middleapi)? You can he
    <td align="center"><a href="https://kellychan.im/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Kelly Peilin Chan"><img src="https://avatars.githubusercontent.com/u/520852?u=6b0f7105f694e7b5cacf410a3f04c7044b469dc8&amp;v=4" width="139" alt="Kelly Peilin Chan"/><br />Kelly Peilin Chan</a></td>
    <td align="center"><a href="https://guyariely.com/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Guy Ariely"><img src="https://avatars.githubusercontent.com/u/42813496?u=edb6b7f563bf28e160a290832e7da57c0506f8ca&amp;v=4" width="139" alt="Guy Ariely"/><br />Guy Ariely</a></td>
    <td align="center"><a href="https://paulsenon.com/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="PaulSenon"><img src="https://avatars.githubusercontent.com/u/19531087?u=6385741eb91d200b8c513ec6045482e301767ca6&amp;v=4" width="139" alt="PaulSenon"/><br />PaulSenon</a></td>
-   <td align="center"><a href="https://nakasyou.how/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Shotaro Nakamura"><img src="https://avatars.githubusercontent.com/u/79000684?u=f644df3f29f0e8677a90967115774564f1d9d6ab&amp;v=4" width="139" alt="Shotaro Nakamura"/><br />Shotaro Nakamura</a></td>
+   <td align="center"><a href="https://piscis.dev/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Alex"><img src="https://avatars.githubusercontent.com/u/326163?u=b245f368bd940cf51d08c0b6bf55f8257f359437&amp;v=4" width="139" alt="Alex"/><br />Alex</a></td>
   </tr>
   <tr>
-   <td align="center"><a href="https://piscis.dev/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Alex"><img src="https://avatars.githubusercontent.com/u/326163?u=b245f368bd940cf51d08c0b6bf55f8257f359437&amp;v=4" width="139" alt="Alex"/><br />Alex</a></td>
    <td align="center"><a href="https://opensource.gubanov.eu/?ref=middleapi&amp;utm_source=middleapi&amp;utm_medium=sponsor" target="_blank" rel="noopener sponsored" title="Andrey Gubanov"><img src="https://avatars.githubusercontent.com/u/1082083?u=c5f2daf7ebece498e85c83367bb37b4e10e2649d&amp;v=4" width="139" alt="Andrey Gubanov"/><br />Andrey Gubanov</a></td>
   </tr>
 </table>
 
-With thanks to [39 past sponsors](https://orpc.dev/sponsors#past-sponsors) who helped get oRPC here.
+With thanks to [40 past sponsors](https://orpc.dev/sponsors#past-sponsors) who helped get oRPC here.
 
 ## Open Source Programs
 

package/dist/coercer.d.mts

@@ -0,0 +1,29 @@
+import type { JsonSchema } from "./types.mjs";
+export interface JsonSchemaCoercerOptions {
+	/**
+	* Maximum digits, excluding a leading `-`, of a string coerced to `bigint`. Longer strings are left unchanged.
+	* `Number.POSITIVE_INFINITY` disables it.
+	*
+	* @default 4300
+	*/
+	maxBigIntDigits?: number | undefined;
+	/**
+	* Maximum coercion steps per input value, where a step applies one schema to one value.
+	* Inputs with fewer than 100 values are budgeted as 100. Past the budget the whole input is left uncoerced,
+	* so validation still runs and reports any mismatch.
+	*
+	* @default 1000
+	*/
+	maxStepsPerValue?: number | undefined;
+}
+export declare class JsonSchemaCoercer {
+	private readonly nativeCoerceOptions;
+	private readonly maxStepsPerValue;
+	/** Reused between calls, since building a context is slow until V8 warms up. */
+	private idleContext;
+	constructor(options?: JsonSchemaCoercerOptions);
+	coerce([schema, optional]: [schema: JsonSchema, optional: boolean], value: unknown): unknown;
+	private coerceInternal;
+	private coerceRef;
+	private extendBudget;
+}

package/dist/coercer.mjs

@@ -0,0 +1,465 @@
+import { DEFAULT_MAX_BIGINT_DIGITS, get, getOwn, isPlainObject, isTypescriptObject, parseBigIntString, toArray, tryOrUndefined } from "@orpc/shared";
+import { decodeJsonPointerSegment } from "./ref-utils.mjs";
+import { JsonSchemaXNativeType } from "./types.mjs";
+
+const UNSATISFIED = 0;
+
+const LOOSELY_SATISFIED = 1;
+
+const SATISFIED = 2;
+
+const NATIVE_TYPES = /* @__PURE__ */ (() => new Map([
+	[JsonSchemaXNativeType.Date, {
+		types: ["string"],
+		is: (value) => value instanceof Date,
+		coerce: (value) => typeof value === "string" ? stringToDate(value) : value
+	}],
+	[JsonSchemaXNativeType.BigInt, {
+		types: [
+			"string",
+			"integer",
+			"number"
+		],
+		is: (value) => typeof value === "bigint",
+		coerce: (value, { maxBigIntDigits }) => typeof value === "string" ? stringToBigInt(value, maxBigIntDigits) : typeof value === "number" ? numberToBigInt(value) : value
+	}],
+	[JsonSchemaXNativeType.Url, {
+		types: ["string"],
+		is: (value) => value instanceof URL,
+		coerce: (value) => typeof value === "string" ? stringToURL(value) : value
+	}],
+	[JsonSchemaXNativeType.Set, {
+		types: ["array"],
+		is: (value) => value instanceof Set,
+		coerce: (value) => Array.isArray(value) ? arrayToSet(value) : value,
+		afterTypeCheck: true
+	}],
+	[JsonSchemaXNativeType.Map, {
+		types: ["array"],
+		is: (value) => value instanceof Map,
+		coerce: (value) => Array.isArray(value) ? arrayToMap(value) : value,
+		afterTypeCheck: true
+	}]
+]))();
+function minSatisfaction(a, b) {
+	return a < b ? a : b;
+}
+const MIN_BUDGETED_VALUES = 100;
+function createContext() {
+	return {
+		rootSchema: true,
+		memo: undefined,
+		memoize: false,
+		steps: 0,
+		maxSteps: 0,
+		input: undefined
+	};
+}
+class CoercionBudgetExceededError extends Error {}
+export class JsonSchemaCoercer {
+	nativeCoerceOptions;
+	maxStepsPerValue;
+	
+	idleContext = createContext();
+	constructor(options = {}) {
+		this.nativeCoerceOptions = { maxBigIntDigits: options.maxBigIntDigits ?? DEFAULT_MAX_BIGINT_DIGITS };
+		this.maxStepsPerValue = options.maxStepsPerValue ?? 1e3;
+	}
+	coerce([schema, optional], value) {
+		if (optional && value === undefined) {
+			return value;
+		}
+		const context = this.idleContext ?? createContext();
+		this.idleContext = undefined;
+		context.rootSchema = schema;
+		context.memoize = false;
+		context.steps = 0;
+		context.maxSteps = this.maxStepsPerValue * MIN_BUDGETED_VALUES;
+		context.input = value;
+		try {
+			const [, coerced] = this.coerceInternal(context, schema, value);
+			return coerced;
+		} catch (error) {
+			
+			if (error instanceof CoercionBudgetExceededError) {
+				return value;
+			}
+			throw error;
+		} finally {
+			
+			context.memo = undefined;
+			context.input = undefined;
+			this.idleContext = context;
+		}
+	}
+	coerceInternal(context, schema, value, appliedRefs) {
+		if (++context.steps > context.maxSteps) {
+			this.extendBudget(context);
+		}
+		if (typeof schema === "boolean") {
+			return [schema ? SATISFIED : UNSATISFIED, value];
+		}
+		if (Array.isArray(schema.type)) {
+			return this.coerceInternal(context, { anyOf: schema.type.map((type) => ({
+				...schema,
+				type
+			})) }, value, appliedRefs);
+		}
+		let coerced = value;
+		let satisfied = SATISFIED;
+		if (typeof schema.$ref === "string") {
+			const resolved = schema.$ref.startsWith("#/") ? get(context.rootSchema, schema.$ref.slice("#/".length).split("/").map(decodeJsonPointerSegment)) : schema.$ref === "#" ? context.rootSchema : undefined;
+			if (resolved !== undefined && !appliedRefs?.has(resolved)) {
+				if (schema.type === "object" || schema.type === "array") {
+					context.memoize = true;
+				}
+				const [subSatisfied, subCoerced] = this.coerceRef(context, resolved, coerced, appliedRefs);
+				coerced = subCoerced;
+				satisfied = minSatisfaction(satisfied, subSatisfied);
+			}
+		}
+		const enumValues = schema.const !== undefined ? [schema.const] : schema.enum;
+		if (enumValues !== undefined && !enumValues.includes(coerced)) {
+			if (typeof coerced === "string") {
+				const numberValue = stringToNumber(coerced);
+				if (enumValues.includes(numberValue)) {
+					coerced = numberValue;
+				} else {
+					const booleanValue = stringToBoolean(coerced);
+					if (enumValues.includes(booleanValue)) {
+						coerced = booleanValue;
+					} else {
+						satisfied = UNSATISFIED;
+					}
+				}
+			} else {
+				satisfied = UNSATISFIED;
+			}
+		}
+		const declaredNativeType = NATIVE_TYPES.get(schema["x-native-type"]);
+		const nativeType = schema.type === undefined || declaredNativeType?.types.includes(schema.type) ? declaredNativeType : undefined;
+		if (nativeType && !nativeType.afterTypeCheck) {
+			coerced = nativeType.coerce(coerced, this.nativeCoerceOptions);
+		}
+		if (schema.type && !nativeType?.is(coerced)) {
+			switch (schema.type) {
+				case "null": {
+					if (coerced !== null) {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+				case "string": {
+					if (typeof coerced !== "string") {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+				case "number": {
+					if (typeof coerced === "string") {
+						coerced = stringToNumber(coerced);
+					}
+					if (typeof coerced !== "number") {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+				case "integer": {
+					if (typeof coerced === "string") {
+						coerced = stringToInteger(coerced);
+					}
+					if (typeof coerced !== "number" || !Number.isInteger(coerced)) {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+				case "boolean": {
+					if (typeof coerced === "string") {
+						coerced = stringToBoolean(coerced);
+					}
+					if (typeof coerced !== "boolean") {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+				case "array": {
+					if (Array.isArray(coerced)) {
+						const prefixItemSchemas = "prefixItems" in schema ? toArray(schema.prefixItems) : Array.isArray(schema.items) ? schema.items : [];
+						const itemSchema = Array.isArray(schema.items) ? schema.additionalItems : schema.items;
+						let shouldUseCoercedItems = false;
+						const coercedItems = coerced.map((item, i) => {
+							const subSchema = prefixItemSchemas[i] ?? itemSchema;
+							if (subSchema === undefined) {
+								satisfied = minSatisfaction(satisfied, LOOSELY_SATISFIED);
+								return item;
+							}
+							const [subSatisfied, subCoerced] = this.coerceInternal(context, subSchema, item);
+							satisfied = minSatisfaction(satisfied, subSatisfied);
+							if (subCoerced !== item) {
+								shouldUseCoercedItems = true;
+							}
+							return subCoerced;
+						});
+						if (typeof schema.minItems === "number" && coercedItems.length < schema.minItems) {
+							satisfied = UNSATISFIED;
+						}
+						if (shouldUseCoercedItems) {
+							coerced = coercedItems;
+						}
+					} else {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+				case "object": {
+					if (Array.isArray(coerced)) {
+						coerced = { ...coerced };
+					}
+					if (isPlainObject(coerced)) {
+						let shouldUseCoercedItems = false;
+						
+						const coercedItems = { ...coerced };
+						const patternProperties = Object.entries(schema.patternProperties ?? {}).flatMap(([key, value]) => {
+							
+							const pattern = tryOrUndefined(() => new RegExp(key));
+							return pattern ? [[pattern, value]] : [];
+						});
+						const propertySchemas = schema.properties ?? {};
+						for (const key of Object.keys(coerced)) {
+							const value = coerced[key];
+							const subSchema = getOwn(propertySchemas, key) ?? patternProperties.find(([pattern]) => pattern.test(key))?.[1] ?? schema.additionalProperties;
+							if (value !== undefined || schema.required?.includes(key)) {
+								if (subSchema === undefined) {
+									satisfied = minSatisfaction(satisfied, LOOSELY_SATISFIED);
+								} else {
+									const [subSatisfied, subCoerced] = this.coerceInternal(context, subSchema, value);
+									coercedItems[key] = subCoerced;
+									satisfied = minSatisfaction(satisfied, subSatisfied);
+									if (subCoerced !== value) {
+										shouldUseCoercedItems = true;
+									}
+								}
+							}
+						}
+						if (schema.required?.some((key) => !Object.hasOwn(coercedItems, key))) {
+							satisfied = UNSATISFIED;
+						}
+						if (shouldUseCoercedItems) {
+							coerced = coercedItems;
+						}
+					} else {
+						satisfied = UNSATISFIED;
+					}
+					break;
+				}
+			}
+		}
+		if (nativeType) {
+			if (nativeType.afterTypeCheck) {
+				coerced = nativeType.coerce(coerced, this.nativeCoerceOptions);
+			}
+			if (!nativeType.is(coerced)) {
+				satisfied = UNSATISFIED;
+			}
+		}
+		if (schema.allOf) {
+			context.memoize = true;
+			for (const subSchema of schema.allOf) {
+				const [subSatisfied, subCoerced] = this.coerceInternal(context, subSchema, coerced, appliedRefs);
+				coerced = subCoerced;
+				satisfied = minSatisfaction(satisfied, subSatisfied);
+			}
+		}
+		for (const key of ["anyOf", "oneOf"]) {
+			if (schema[key]) {
+				context.memoize = true;
+				
+				let best;
+				for (const subSchema of schema[key]) {
+					const [subSatisfied, subCoerced] = this.coerceInternal(context, subSchema, coerced, appliedRefs);
+					if (subSatisfied === UNSATISFIED) {
+						continue;
+					}
+					if (subCoerced === coerced) {
+						best = {
+							satisfied: subSatisfied,
+							value: subCoerced
+						};
+						break;
+					}
+					if (!best || subSatisfied > best.satisfied) {
+						best = {
+							satisfied: subSatisfied,
+							value: subCoerced
+						};
+					}
+				}
+				
+				if (best) {
+					coerced = best.value;
+					satisfied = minSatisfaction(satisfied, best.satisfied);
+				} else {
+					satisfied = UNSATISFIED;
+				}
+			}
+		}
+		if (typeof schema.not !== "undefined") {
+			context.memoize = true;
+			const [notSatisfied] = this.coerceInternal(context, schema.not, coerced, appliedRefs);
+			if (notSatisfied !== UNSATISFIED) {
+				satisfied = UNSATISFIED;
+			}
+		}
+		return [satisfied, coerced];
+	}
+	coerceRef(context, resolved, value, appliedRefs) {
+		let memo;
+		
+		if (context.memoize && !appliedRefs?.size && isTypescriptObject(value)) {
+			context.memo ??= new Map();
+			memo = context.memo.get(resolved);
+			if (!memo) {
+				memo = new Map();
+				context.memo.set(resolved, memo);
+			}
+			const cached = memo.get(value);
+			if (cached) {
+				return cached;
+			}
+		}
+		appliedRefs ??= new Set();
+		appliedRefs.add(resolved);
+		const result = this.coerceInternal(context, resolved, value, appliedRefs);
+		appliedRefs.delete(resolved);
+		memo?.set(value, result);
+		return result;
+	}
+	extendBudget(context) {
+		const limit = 2 * context.steps / this.maxStepsPerValue;
+		context.maxSteps = this.maxStepsPerValue * Math.max(countValues(context.input, limit), MIN_BUDGETED_VALUES);
+		if (context.steps > context.maxSteps) {
+			throw new CoercionBudgetExceededError();
+		}
+	}
+}
+function countValues(input, limit) {
+	const walked = new Set();
+	const stack = [input];
+	let count = 1;
+	while (stack.length) {
+		const value = stack.pop();
+		if ((Array.isArray(value) || isPlainObject(value)) && !walked.has(value)) {
+			walked.add(value);
+			const items = Array.isArray(value) ? value : Object.values(value);
+			for (let i = 0; i < items.length; i++) {
+				if (++count >= limit) {
+					return count;
+				}
+				const item = items[i];
+				if (isTypescriptObject(item)) {
+					stack.push(item);
+				}
+			}
+		}
+	}
+	return count;
+}
+const NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function stringToNumber(value) {
+	if (!NUMBER_PATTERN.test(value)) {
+		return value;
+	}
+	const num = Number(value);
+	
+	if (num < Number.MIN_SAFE_INTEGER || num > Number.MAX_SAFE_INTEGER) {
+		return value;
+	}
+	return num;
+}
+const INTEGER_PATTERN = /^-?(?:0|[1-9]\d*)$/;
+function stringToInteger(value) {
+	if (!INTEGER_PATTERN.test(value)) {
+		return value;
+	}
+	const num = Number(value);
+	if (!Number.isSafeInteger(num)) {
+		return value;
+	}
+	return num;
+}
+function stringToBigInt(value, maxDigits) {
+	return parseBigIntString(value, maxDigits) ?? value;
+}
+function numberToBigInt(value) {
+	if (!Number.isInteger(value)) {
+		return value;
+	}
+	return BigInt(value);
+}
+function stringToBoolean(value) {
+	const lower = value.toLowerCase();
+	if (lower === "false" || lower === "off") {
+		return false;
+	}
+	if (lower === "true" || lower === "on") {
+		return true;
+	}
+	return value;
+}
+const DATE_TIME_PATTERN = /^(?!-0{6})(?:[+-]\d{2})?\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+const DAYS_IN_MONTH = [
+	31,
+	29,
+	31,
+	30,
+	31,
+	30,
+	31,
+	31,
+	30,
+	31,
+	30,
+	31
+];
+function stringToDate(value) {
+	if (!DATE_TIME_PATTERN.test(value)) {
+		return value;
+	}
+	const yearEnd = value.indexOf("-", 1);
+	const month = readTwoDigits(value, yearEnd + 1);
+	const day = readTwoDigits(value, yearEnd + 4);
+	if (day < 1 || day > (DAYS_IN_MONTH[month - 1] ?? 0) || month === 2 && day === 29 && !isLeapYear(Number(value.slice(0, yearEnd)))) {
+		return value;
+	}
+	const date = new Date(value);
+	if (Number.isNaN(date.getTime())) {
+		return value;
+	}
+	return date;
+}
+function readTwoDigits(value, index) {
+	return (value.charCodeAt(index) - 48) * 10 + value.charCodeAt(index + 1) - 48;
+}
+function isLeapYear(year) {
+	return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+function stringToURL(value) {
+	return tryOrUndefined(() => new URL(value)) ?? value;
+}
+function arrayToSet(value) {
+	const set = new Set(value);
+	if (set.size !== value.length) {
+		return value;
+	}
+	return set;
+}
+function arrayToMap(value) {
+	if (value.some((item) => !Array.isArray(item) || item.length !== 2)) {
+		return value;
+	}
+	const result = new Map(value);
+	if (result.size !== value.length) {
+		return value;
+	}
+	return result;
+}

package/dist/composition-utils.d.mts

@@ -0,0 +1,41 @@
+/**
+* These utilities assume the schema has only one root-level `$defs` object
+* and exclusively use absolute JSON pointers for `$ref` values.
+*/
+import type { JsonSchema } from "./types.mjs";
+import type { JsonArraySchema, JsonObjectSchema } from "./utils.mjs";
+/**
+* Combines multiple schemas under the requested composition keyword, promoting branch `$defs` to the root.
+*/
+export declare function combineJsonSchemasWithComposition(keyword: "allOf" | "anyOf" | "oneOf", schemas: JsonSchema[]): JsonSchema;
+export type JsonObjectSchemaEntry = [name: string, schema: JsonSchema, optional: boolean];
+/**
+* Combines object property entries back into a single object schema.
+* When given, `additionalProperties` constrains every property the entries do not name.
+*/
+export declare function combineJsonObjectSchemaEntries(entries: JsonObjectSchemaEntry[], additionalProperties?: JsonSchema): JsonObjectSchema;
+/**
+* Parses an object schema, or a composition of object schemas, into property entries.
+*/
+export declare function extractJsonObjectSchemaEntries(schema: JsonSchema): JsonObjectSchemaEntry[] | undefined;
+/**
+* Returns the `additionalProperties` an object schema declares at its root, following root-local refs,
+* with the root `$defs` attached so it can be passed to {@link combineJsonObjectSchemaEntries}.
+* Composition branches are not inspected, since their keyword only constrains that branch.
+*/
+export declare function extractJsonObjectSchemaAdditionalProperties(schema: JsonSchema): JsonSchema | undefined;
+/**
+* Returns true when an object can stand for every value the schema describes: the schema constrains objects,
+* by `type` or object keywords, composes only such schemas, or is unconstrained, since an object satisfies it.
+* Unlike {@link extractJsonObjectSchemaEntries}, an unconstrained schema counts as object-like.
+*/
+export declare function isJsonObjectLikeSchema(schema: JsonSchema): boolean;
+/**
+* Flattens `anyOf` and `oneOf` unions when they are the only active constraints.
+*/
+export declare function flattenJsonUnionSchema(schema: JsonSchema): JsonSchema[];
+/**
+* Matches a union made of a single item schema and its array form.
+*/
+export declare function matchArrayableJsonSchema(schema: JsonSchema): undefined | [itemSchema: JsonSchema, arraySchema: JsonArraySchema];
+export declare function deduplicateJsonSchemas(schemas: JsonSchema[]): JsonSchema[];