@orpc/zod 2.0.0-beta.49 → 2.0.0-beta.50

package/dist/converter.d.ts

@@ -1,16 +1,16 @@
-import type { AnySchema, JsonSchema, JsonSchemaConverter, JsonSchemaConverterDirection } from '@orpc/json-schema';
-import type { ToJSONSchemaParams } from 'zod/v4/core';
-export interface ZodToJsonSchemaConverterOptions extends Omit<ToJSONSchemaParams, 'target' | 'io'> {
-    /**
-     * Caches conversion results in a WeakMap keyed by the Zod schema instance,
-     * so converting the same schema again is free.
-     *
-     * When enabled, repeated conversions return the same JSON schema object,
-     * so treat returned schemas as immutable.
-     *
-     * @default false
-     */
-    cache?: boolean | undefined;
+import { AnySchema, JsonSchema, JsonSchemaConverter, JsonSchemaConverterDirection } from "@orpc/json-schema";
+import { ToJSONSchemaParams } from "zod/v4/core";
+export interface ZodToJsonSchemaConverterOptions extends Omit<ToJSONSchemaParams, "target" | "io"> {
+  /**
+   * Caches conversion results in a WeakMap keyed by the Zod schema instance,
+   * so converting the same schema again is free.
+   *
+   * When enabled, repeated conversions return the same JSON schema object,
+   * so treat returned schemas as immutable.
+   *
+   * @default false
+   */
+  cache?: boolean | undefined;
 }
 /**
  * Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
@@ -19,12 +19,12 @@ export interface ZodToJsonSchemaConverterOptions extends Omit<ToJSONSchemaParams
  * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
  */
 export declare class ZodToJsonSchemaConverter implements JsonSchemaConverter {
-    private readonly toJSONSchemaParams;
-    private readonly cache;
-    constructor({ cache, ...toJSONSchemaParams }?: ZodToJsonSchemaConverterOptions);
-    condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
-    convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
-    private convertUncached;
-    private convertZod;
-    private getCustomJsonSchema;
-}
+  private readonly toJSONSchemaParams;
+  private readonly cache;
+  constructor({ cache, ...toJSONSchemaParams }?: ZodToJsonSchemaConverterOptions);
+  condition(schema: AnySchema | undefined, _direction: JsonSchemaConverterDirection): boolean;
+  convert(schema: AnySchema | undefined, direction: JsonSchemaConverterDirection): [jsonSchema: JsonSchema, optional: boolean];
+  private convertUncached;
+  private convertZod;
+  private getCustomJsonSchema;
+}

package/dist/converter.js

@@ -1,123 +1,107 @@
-import { isStandardSchemaOptional, JsonSchemaFormat, JsonSchemaXNativeType, } from '@orpc/json-schema';
-import { process as processZodSchema, toJSONSchema } from 'zod/v4/core';
-import { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, } from './registries.js';
+import { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY } from "./registries.js";
+import { JsonSchemaFormat, JsonSchemaXNativeType, isStandardSchemaOptional } from "@orpc/json-schema";
+import { process, toJSONSchema } from "zod/v4/core";
+// src/converter.ts
 /**
- * Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
- * with additional support for types such as `z.bigint()`, `z.date()`, `z.set()`, and `z.map()`.
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-export class ZodToJsonSchemaConverter {
-    toJSONSchemaParams;
-    cache;
-    constructor({ cache, ...toJSONSchemaParams } = {}) {
-        this.toJSONSchemaParams = toJSONSchemaParams;
-        if (cache) {
-            this.cache = { input: new WeakMap(), output: new WeakMap() };
-        }
-    }
-    condition(schema, _direction) {
-        return schema?.['~standard'].vendor === 'zod';
-    }
-    convert(schema, direction) {
-        const zodSchema = schema;
-        if (this.cache) {
-            const cached = this.cache[direction].get(zodSchema);
-            if (cached) {
-                return cached;
-            }
-        }
-        const result = this.convertUncached(zodSchema, direction);
-        if (this.cache) {
-            this.cache[direction].set(zodSchema, result);
-        }
-        return result;
-    }
-    convertUncached(zodSchema, direction) {
-        const jsonSchema = this.convertZod(zodSchema, direction);
-        return [jsonSchema, isStandardSchemaOptional(zodSchema, direction)];
-    }
-    convertZod(schema, direction) {
-        const { unrepresentable = 'any' } = this.toJSONSchemaParams;
-        const jsonSchema = toJSONSchema(schema, {
-            ...this.toJSONSchemaParams,
-            target: 'draft-2020-12',
-            io: direction,
-            unrepresentable(info) {
-                return (convertNativeType(this, info.zodSchema, info.path) ??
-                    (typeof unrepresentable === 'function' ? unrepresentable(info) : unrepresentable));
-            },
-            override: (ctx) => {
-                const customJsonSchema = this.getCustomJsonSchema(ctx.zodSchema, direction);
-                if (customJsonSchema) {
-                    Object.assign(ctx.jsonSchema, customJsonSchema);
-                }
-                this.toJSONSchemaParams.override?.(ctx);
-            },
-        });
-        // Since the default oRPC format is always draft/2020-12,
-        // `$schema` can be safely omitted here.
-        const { $schema: _schema, ...rest } = jsonSchema;
-        return rest;
-    }
-    getCustomJsonSchema(schema, direction) {
-        const general = JSON_SCHEMA_REGISTRY.get(schema);
-        const directional = direction === 'input'
-            ? JSON_SCHEMA_INPUT_REGISTRY.get(schema)
-            : JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
-        if (general === undefined && directional === undefined) {
-            return undefined;
-        }
-        return { ...general, ...directional };
-    }
-}
+* Converts Zod schemas into JSON Schema using Zod's built-in `toJSONSchema`,
+* with additional support for types such as `z.bigint()`, `z.date()`, `z.set()`, and `z.map()`.
+*
+* @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+*/
+var ZodToJsonSchemaConverter = class {
+	toJSONSchemaParams;
+	cache;
+	constructor({ cache, ...toJSONSchemaParams } = {}) {
+		this.toJSONSchemaParams = toJSONSchemaParams;
+		if (cache) this.cache = {
+			input: /* @__PURE__ */ new WeakMap(),
+			output: /* @__PURE__ */ new WeakMap()
+		};
+	}
+	condition(schema, _direction) {
+		return schema?.["~standard"].vendor === "zod";
+	}
+	convert(schema, direction) {
+		const zodSchema = schema;
+		if (this.cache) {
+			const cached = this.cache[direction].get(zodSchema);
+			if (cached) return cached;
+		}
+		const result = this.convertUncached(zodSchema, direction);
+		if (this.cache) this.cache[direction].set(zodSchema, result);
+		return result;
+	}
+	convertUncached(zodSchema, direction) {
+		return [this.convertZod(zodSchema, direction), isStandardSchemaOptional(zodSchema, direction)];
+	}
+	convertZod(schema, direction) {
+		const { unrepresentable = "any" } = this.toJSONSchemaParams;
+		const { $schema: _schema, ...rest } = toJSONSchema(schema, {
+			...this.toJSONSchemaParams,
+			target: "draft-2020-12",
+			io: direction,
+			unrepresentable(info) {
+				return convertNativeType(this, info.zodSchema, info.path) ?? (typeof unrepresentable === "function" ? unrepresentable(info) : unrepresentable);
+			},
+			override: (ctx) => {
+				const customJsonSchema = this.getCustomJsonSchema(ctx.zodSchema, direction);
+				if (customJsonSchema) Object.assign(ctx.jsonSchema, customJsonSchema);
+				this.toJSONSchemaParams.override?.(ctx);
+			}
+		});
+		return rest;
+	}
+	getCustomJsonSchema(schema, direction) {
+		const general = JSON_SCHEMA_REGISTRY.get(schema);
+		const directional = direction === "input" ? JSON_SCHEMA_INPUT_REGISTRY.get(schema) : JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+		if (general === void 0 && directional === void 0) return;
+		return {
+			...general,
+			...directional
+		};
+	}
+};
 function convertNativeType(ctx, zodSchema, path) {
-    const def = zodSchema._zod.def;
-    switch (def.type) {
-        case 'bigint':
-            return {
-                'type': 'string',
-                'pattern': '^-?[0-9]+$',
-                'x-native-type': JsonSchemaXNativeType.BigInt,
-            };
-        case 'date':
-            return {
-                'type': 'string',
-                'format': JsonSchemaFormat.DateTime,
-                'x-native-type': JsonSchemaXNativeType.Date,
-            };
-        case 'set':
-        case 'map': {
-            const schemaPath = [];
-            for (const [seenSchema, seen] of ctx.seen) {
-                if (seen.path &&
-                    seen.path.length <= path.length &&
-                    seen.path.every((segment, i) => segment === path[i])) {
-                    schemaPath.push(seenSchema);
-                }
-            }
-            const processItems = (schema, ...segments) => processZodSchema(schema, ctx, { path: [...path, 'items', ...segments], schemaPath });
-            return def.type === 'set'
-                ? {
-                    'type': 'array',
-                    'uniqueItems': true,
-                    'items': processItems(def.valueType),
-                    'x-native-type': JsonSchemaXNativeType.Set,
-                }
-                : {
-                    'type': 'array',
-                    'items': {
-                        type: 'array',
-                        prefixItems: [
-                            processItems(def.keyType, 'prefixItems', 0),
-                            processItems(def.valueType, 'prefixItems', 1),
-                        ],
-                        maxItems: 2,
-                        minItems: 2,
-                    },
-                    'x-native-type': JsonSchemaXNativeType.Map,
-                };
-        }
-    }
-    return undefined;
+	const def = zodSchema._zod.def;
+	switch (def.type) {
+		case "bigint": return {
+			"type": "string",
+			"pattern": "^-?[0-9]+$",
+			"x-native-type": JsonSchemaXNativeType.BigInt
+		};
+		case "date": return {
+			"type": "string",
+			"format": JsonSchemaFormat.DateTime,
+			"x-native-type": JsonSchemaXNativeType.Date
+		};
+		case "set":
+		case "map": {
+			const schemaPath = [];
+			for (const [seenSchema, seen] of ctx.seen) if (seen.path && seen.path.length <= path.length && seen.path.every((segment, i) => segment === path[i])) schemaPath.push(seenSchema);
+			const processItems = (schema, ...segments) => process(schema, ctx, {
+				path: [
+					...path,
+					"items",
+					...segments
+				],
+				schemaPath
+			});
+			return def.type === "set" ? {
+				"type": "array",
+				"uniqueItems": true,
+				"items": processItems(def.valueType),
+				"x-native-type": JsonSchemaXNativeType.Set
+			} : {
+				"type": "array",
+				"items": {
+					type: "array",
+					prefixItems: [processItems(def.keyType, "prefixItems", 0), processItems(def.valueType, "prefixItems", 1)],
+					maxItems: 2,
+					minItems: 2
+				},
+				"x-native-type": JsonSchemaXNativeType.Map
+			};
+		}
+	}
 }
+export { ZodToJsonSchemaConverter };

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export * from './converter.ts';
-export * from './registries.ts';
-export type { JsonSchema } from '@orpc/json-schema';
+import { ZodToJsonSchemaConverter, ZodToJsonSchemaConverterOptions } from "./converter.js";
+import { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY } from "./registries.js";
+import { JsonSchema } from "@orpc/json-schema";
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, type JsonSchema, ZodToJsonSchemaConverter, ZodToJsonSchemaConverterOptions };

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from './converter.js';
-export * from './registries.js';
+export { ZodToJsonSchemaConverter } from "./converter.js";
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY } from "./registries.js";

package/dist/registries.d.ts

@@ -1,5 +1,5 @@
-import type { JsonSchema } from '@orpc/json-schema';
-import type { $input, $output, $ZodRegistry } from 'zod/v4/core';
+import { JsonSchema } from "@orpc/json-schema";
+import { $ZodRegistry, $input, $output } from "zod/v4/core";
 /**
  * Zod registry for customizing generated JSON schema, can use both for .input and .output
  *
@@ -59,4 +59,4 @@ export declare const JSON_SCHEMA_INPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema
  *
  * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
  */
-export declare const JSON_SCHEMA_OUTPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$output>, boolean>>;
+export declare const JSON_SCHEMA_OUTPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$output>, boolean>>;

package/dist/registries.js

@@ -1,64 +1,63 @@
-import { registry } from 'zod/v4/core';
+import { registry } from "zod/v4/core";
+// src/registries.ts
 /**
- * Zod registry for customizing generated JSON schema, can use both for .input and .output
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.number(),
- * })
- *
- * JSON_SCHEMA_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: 20 }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-export const JSON_SCHEMA_REGISTRY = 
-/* @__PURE__ */ registry();
+* Zod registry for customizing generated JSON schema, can use both for .input and .output
+*
+* @example
+* ```ts
+* import { JSON_SCHEMA_REGISTRY } from '@orpc/zod'
+*
+* const user = z.object({
+*   name: z.string(),
+*   age: z.number(),
+* })
+*
+* JSON_SCHEMA_REGISTRY.add(user, {
+*   examples: [{ name: 'John', age: 20 }],
+* })
+* ```
+*
+* @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+*/
+const JSON_SCHEMA_REGISTRY = /* @__PURE__ */ registry();
 /**
- * Zod registry for customizing generated JSON schema, only useful for .input
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.string().transform(v => Number(v)),
- * })
- *
- * JSON_SCHEMA_INPUT_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: "20" }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-export const JSON_SCHEMA_INPUT_REGISTRY = 
-/* @__PURE__ */ registry();
+* Zod registry for customizing generated JSON schema, only useful for .input
+*
+* @example
+* ```ts
+* import { JSON_SCHEMA_INPUT_REGISTRY } from '@orpc/zod'
+*
+* const user = z.object({
+*   name: z.string(),
+*   age: z.string().transform(v => Number(v)),
+* })
+*
+* JSON_SCHEMA_INPUT_REGISTRY.add(user, {
+*   examples: [{ name: 'John', age: "20" }],
+* })
+* ```
+*
+* @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+*/
+const JSON_SCHEMA_INPUT_REGISTRY = /* @__PURE__ */ registry();
 /**
- * Zod registry for customizing generated JSON schema, only useful for .output
- *
- * @example
- * ```ts
- * import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod'
- *
- * const user = z.object({
- *   name: z.string(),
- *   age: z.string().transform(v => Number(v)),
- * })
- *
- * JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
- *   examples: [{ name: 'John', age: 20 }],
- * })
- * ```
- *
- * @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
- */
-export const JSON_SCHEMA_OUTPUT_REGISTRY = 
-/* @__PURE__ */ registry();
+* Zod registry for customizing generated JSON schema, only useful for .output
+*
+* @example
+* ```ts
+* import { JSON_SCHEMA_OUTPUT_REGISTRY } from '@orpc/zod'
+*
+* const user = z.object({
+*   name: z.string(),
+*   age: z.string().transform(v => Number(v)),
+* })
+*
+* JSON_SCHEMA_OUTPUT_REGISTRY.add(user, {
+*   examples: [{ name: 'John', age: 20 }],
+* })
+* ```
+*
+* @see {@link https://orpc.dev/docs/integrations/zod | Zod Integration}
+*/
+const JSON_SCHEMA_OUTPUT_REGISTRY = /* @__PURE__ */ registry();
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orpc/zod",
-  "version": "2.0.0-beta.49",
+  "version": "2.0.0-beta.50",
   "description": "Zod integration for oRPC: convert Zod schemas into JSON Schema for OpenAPI generation",
   "keywords": [
     "json-schema",
@@ -36,7 +36,7 @@
     }
   },
   "dependencies": {
-    "@orpc/json-schema": "2.0.0-beta.49"
+    "@orpc/json-schema": "2.0.0-beta.50"
   },
   "devDependencies": {
     "zod": "^4.6.7"