@orpc/json-schema 1.14.6 → 2.0.0-beta.10

package/dist/index.d.ts

@@ -1,11 +1,16 @@
-import * as Draft07 from 'json-schema-typed/draft-07';
-import * as Draft2019 from 'json-schema-typed/draft-2019-09';
 import * as Draft2020 from 'json-schema-typed/draft-2020-12';
-import { ConditionalSchemaConverter } from '@orpc/openapi';
+export { Format as JsonSchemaFormat, TypeName as JsonSchemaType } from 'json-schema-typed/draft-2020-12';
+import { AnySchema, RouterContract } from '@orpc/contract';
+export { AnySchema, Schema } from '@orpc/contract';
+import { Promisable } from '@orpc/shared';
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import { ClientContext } from '@orpc/client';
+import { StandardLinkPlugin, StandardLinkOptions } from '@orpc/client/standard';
+import { StandardJSONSchemaV1 } from '@standard-schema/spec';
 
-type JsonSchema = Draft2020.JSONSchema | Draft2019.JSONSchema | Draft07.JSONSchema;
+type JsonSchema = Draft2020.JSONSchema;
+type JsonSchemaKeywords = typeof Draft2020.keywords[number];
 declare enum JsonSchemaXNativeType {
     BigInt = "bigint",
     RegExp = "regexp",
@@ -15,25 +20,168 @@ declare enum JsonSchemaXNativeType {
     Map = "map"
 }
 
-interface JsonSchemaCoerceOptions {
-    components?: Record<string, JsonSchema>;
-}
 declare class JsonSchemaCoercer {
-    #private;
-    coerce(schema: JsonSchema, value: unknown, options?: JsonSchemaCoerceOptions): unknown;
+    coerce([schema, optional]: [schema: JsonSchema, optional: boolean], value: unknown): unknown;
+    private coerceInternal;
+}
+
+/**
+ * These utilities assume the schema has only one root-level `$defs` object
+ * and exclusively use absolute JSON pointers for `$ref` values.
+ */
+
+declare function isJsonPrimitiveSchema(schema: JsonSchema): schema is JsonSchema & object;
+type JsonFileSchema = JsonSchema & object & {
+    type: 'string';
+    contentMediaType?: string;
+};
+/**
+ * Returns true when the schema is a file-like string schema.
+ */
+declare function isJsonFileSchema(schema: JsonSchema): schema is JsonFileSchema;
+type JsonObjectSchema = JsonSchema & object & {
+    type: 'object';
+};
+/**
+ * Returns true when the schema is an object schema.
+ */
+declare function isJsonObjectSchema(schema: JsonSchema): schema is JsonObjectSchema;
+type JsonArraySchema = JsonSchema & object & {
+    type: 'array';
+};
+/**
+ * Returns true when the schema is an array schema.
+ */
+declare function isJsonArraySchema(schema: JsonSchema): schema is JsonArraySchema;
+/**
+ * Returns true when the schema does not apply any recognized constraints.
+ */
+declare function isUnconstrainedSchema(schema: JsonSchema): boolean;
+/**
+ * Ensures a JSON Schema is represented as an object schema document.
+ */
+declare function ensureJsonSchemaObject(schema: JsonSchema): Exclude<JsonSchema, boolean>;
+
+/**
+ * These utilities assume the schema has only one root-level `$defs` object
+ * and exclusively use absolute JSON pointers for `$ref` values.
+ */
+
+/**
+ * Combines multiple schemas under the requested composition keyword, promoting branch `$defs` to the root.
+ */
+declare function combineJsonSchemasWithComposition(keyword: 'allOf' | 'anyOf' | 'oneOf', schemas: JsonSchema[]): JsonSchema;
+type JsonObjectSchemaEntry = [name: string, schema: JsonSchema, optional: boolean];
+/**
+ * Combines object property entries back into a single object schema.
+ */
+declare function combineJsonObjectSchemaEntries(entries: JsonObjectSchemaEntry[]): JsonObjectSchema;
+/**
+ * Parses an object schema, or a composition of object schemas, into property entries.
+ */
+declare function extractJsonObjectSchemaEntries(schema: JsonSchema): JsonObjectSchemaEntry[] | undefined;
+/**
+ * Flattens `anyOf` and `oneOf` unions when they are the only active constraints.
+ */
+declare function flattenJsonUnionSchema(schema: JsonSchema): JsonSchema[];
+/**
+ * Matches a union made of a single item schema and its array form.
+ */
+declare function matchArrayableJsonSchema(schema: JsonSchema): undefined | [itemSchema: JsonSchema, arraySchema: JsonArraySchema];
+declare function deduplicateJsonSchemas(schemas: JsonSchema[]): JsonSchema[];
+
+type JsonSchemaConverterDirection = 'input' | 'output';
+interface JsonSchemaConverter {
+    /**
+     * Determines whether this converter can handle the given schema.
+     */
+    condition(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): Promisable<boolean>;
+    /**
+     * Converts an ORPC schema to a JSON Schema representation.
+     */
+    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): Promisable<[jsonSchema: JsonSchema, optional: boolean]>;
+}
+declare class DelegatingJsonSchemaConverter implements Pick<JsonSchemaConverter, 'convert'> {
+    private readonly converters;
+    constructor(converters?: JsonSchemaConverter[]);
+    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): Promise<[jsonSchema: JsonSchema, optional: boolean]>;
+}
+
+/**
+ * These utilities assume the schema has only one root-level `$defs` object
+ * and exclusively use absolute JSON pointers for `$ref` values.
+ */
+
+/**
+ * Encodes a JSON Pointer segment according to RFC 6901.
+ *
+ * https://datatracker.ietf.org/doc/html/rfc6901
+ */
+declare function encodeJsonPointerSegment(segment: string): string;
+/**
+ * Decodes a JSON Pointer segment according to RFC 6901.
+ *
+ * https://datatracker.ietf.org/doc/html/rfc6901
+ */
+declare function decodeJsonPointerSegment(segment: string): string;
+declare function mapJsonSchemaRefs(value: JsonSchema, map: (ref: string, path: Array<string | number>) => string, schemaLevel?: boolean, path?: Array<string | number>): JsonSchema;
+/**
+ * Rewrites recursive root `#` refs by moving the schema body into `$defs`.
+ */
+declare function hoistRecursiveRefToDef(schema: JsonSchema): JsonSchema;
+/**
+ * Resolves a local `$ref` at the **root level** of the given schema, if present.
+ *
+ * Only handles refs of the form `#/$defs/<name>` pointing into the provided
+ * (or schema-embedded) `$defs` map. Nested `$ref`s inside sub-schemas are
+ * intentionally left untouched.
+ *
+ * If the ref cannot be resolved (missing `$defs`, unknown key, etc.) the
+ * schema is returned as-is.
+ *
+ * @param schema - The schema whose root-level `$ref` should be resolved.
+ * @param $defs - Definition map to resolve against. If omitted, falls back to
+ *   `schema.$defs`. When provided, takes precedence over any `$defs` embedded
+ *   in the schema.
+ */
+declare function resolveJsonSchemaRootLocalRef(schema: JsonSchema, $defs?: Exclude<JsonSchema, boolean>['$defs']): JsonSchema;
+
+interface SmartCoercionHandlerPluginOptions {
+    converters?: undefined | JsonSchemaConverter[];
+}
+declare class SmartCoercionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    private readonly converter;
+    private readonly coercer;
+    private readonly cache;
+    constructor(options?: SmartCoercionHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+    private coerceValue;
 }
 
-interface SmartCoercionPluginOptions {
-    schemaConverters?: readonly ConditionalSchemaConverter[];
+interface SmartCoercionLinkPluginOptions {
+    converters?: undefined | JsonSchemaConverter[];
 }
-declare class SmartCoercionPlugin<T extends Context> implements StandardHandlerPlugin<T> {
-    #private;
+declare class SmartCoercionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    name: string;
+    /**
+     * Output and error values should be coerced before validation.
+     */
+    after: string[];
     private readonly converter;
     private readonly coercer;
     private readonly cache;
-    constructor(options?: SmartCoercionPluginOptions);
-    init(options: StandardHandlerOptions<T>): void;
+    constructor(contract: RouterContract, options?: SmartCoercionLinkPluginOptions);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+    private coerceValue;
+}
+
+declare class StandardJsonSchemaConverter implements JsonSchemaConverter {
+    condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
+    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
+    convertInternal(schema: StandardJSONSchemaV1 & AnySchema, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
 }
 
-export { JsonSchemaCoercer, JsonSchemaXNativeType, SmartCoercionPlugin };
-export type { JsonSchema, JsonSchemaCoerceOptions, SmartCoercionPluginOptions };
+export { DelegatingJsonSchemaConverter, JsonSchemaCoercer, JsonSchemaXNativeType, SmartCoercionHandlerPlugin, SmartCoercionLinkPlugin, StandardJsonSchemaConverter, combineJsonObjectSchemaEntries, combineJsonSchemasWithComposition, decodeJsonPointerSegment, deduplicateJsonSchemas, encodeJsonPointerSegment, ensureJsonSchemaObject, extractJsonObjectSchemaEntries, flattenJsonUnionSchema, hoistRecursiveRefToDef, isJsonArraySchema, isJsonFileSchema, isJsonObjectSchema, isJsonPrimitiveSchema, isUnconstrainedSchema, mapJsonSchemaRefs, matchArrayableJsonSchema, resolveJsonSchemaRootLocalRef };
+export type { JsonArraySchema, JsonFileSchema, JsonObjectSchema, JsonObjectSchemaEntry, JsonSchema, JsonSchemaConverter, JsonSchemaConverterDirection, JsonSchemaKeywords, SmartCoercionHandlerPluginOptions, SmartCoercionLinkPluginOptions };