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

package/README.md

@@ -5,7 +5,7 @@
     <img alt="codecov" src="https://codecov.io/gh/middleapi/orpc/branch/main/graph/badge.svg">
   </a>
   <a href="https://www.npmjs.com/package/@orpc/zod">
-    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fzod?logo=npm" />
+    <img alt="monthly downloads" src="https://img.shields.io/npm/dm/%40orpc%2Fzod?logo=npm" />
   </a>
   <a href="https://app.codspeed.io/middleapi/orpc?utm_source=badge">
     <img alt="CodSpeed" src="https://img.shields.io/endpoint?url=https://codspeed.io/badge.json" />
@@ -41,10 +41,11 @@ export const router = {
 Then call them from a client that knows every input and output, without generating anything:
 
 ```ts
-import type { RouterClient } from '@orpc/server'
-import type { router } from './router'
 import { createORPCClient } from '@orpc/client'
 import { RPCLink } from '@orpc/client/fetch'
+import type { RouterClient } from '@orpc/server'
+
+import type { router } from './router'
 
 const link = new RPCLink({ origin: 'http://localhost:3000', url: '/rpc' })
 const client: RouterClient<typeof router> = createORPCClient(link)
@@ -208,7 +209,6 @@ With thanks to [40 past sponsors](https://orpc.dev/sponsors#past-sponsors) who h
   <tr>
    <td align="center"><a href="https://claude.com/contact-sales/claude-for-oss" target="_blank" rel="noopener" title="Claude for Open Source"><img src="https://cdn.simpleicons.org/claude" width="64" alt="Claude"/><br />Claude</a></td>
    <td align="center"><a href="https://pullfrog.com/for-oss" target="_blank" rel="noopener" title="Pullfrog for OSS"><img src="https://avatars.githubusercontent.com/in/1768019?s=128&amp;v=4" width="64" alt="Pullfrog"/><br />Pullfrog</a></td>
-   <td align="center"><a href="https://macroscope.com/open-source" target="_blank" rel="noopener" title="Macroscope for Open Source"><img src="https://avatars.githubusercontent.com/in/900172?s=128&amp;v=4" width="64" alt="Macroscope"/><br />Macroscope</a></td>
   </tr>
 </table>
 

package/dist/converter.d.ts

@@ -0,0 +1,30 @@
+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;
+}
+/**
+ * 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 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;
+}

package/dist/converter.js

@@ -0,0 +1,123 @@
+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';
+/**
+ * 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 };
+    }
+}
+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;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './converter.ts';
+export * from './registries.ts';
+export type { JsonSchema } from '@orpc/json-schema';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './converter.js';
+export * from './registries.js';

package/dist/registries.d.ts

@@ -0,0 +1,62 @@
+import type { JsonSchema } from '@orpc/json-schema';
+import type { $input, $output, $ZodRegistry } from 'zod/v4/core';
+/**
+ * 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 declare const JSON_SCHEMA_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$input | $output>, boolean>>;
+/**
+ * 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 declare const JSON_SCHEMA_INPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$input>, boolean>>;
+/**
+ * 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 declare const JSON_SCHEMA_OUTPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$output>, boolean>>;

package/dist/registries.js

@@ -0,0 +1,64 @@
+import { registry } from 'zod/v4/core';
+/**
+ * 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, 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 .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();

package/package.json

@@ -1,51 +1,48 @@
 {
   "name": "@orpc/zod",
-  "type": "module",
-  "version": "2.0.0-beta.48",
+  "version": "2.0.0-beta.49",
   "description": "Zod integration for oRPC: convert Zod schemas into JSON Schema for OpenAPI generation",
-  "license": "MIT",
-  "funding": [
-    "https://github.com/sponsors/dinwwwh",
-    "https://opencollective.com/middleapi"
+  "keywords": [
+    "json-schema",
+    "openapi",
+    "orpc",
+    "typesafe",
+    "typescript",
+    "validation",
+    "zod"
   ],
   "homepage": "https://orpc.dev",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/middleapi/orpc.git",
     "directory": "packages/zod"
   },
-  "keywords": [
-    "orpc",
-    "zod",
-    "json-schema",
-    "openapi",
-    "validation",
-    "typescript",
-    "typesafe"
+  "funding": [
+    "https://github.com/sponsors/dinwwwh",
+    "https://opencollective.com/middleapi"
   ],
+  "files": [
+    "dist"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.mjs"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
-  "files": [
-    "dist"
-  ],
-  "peerDependencies": {
-    "zod": ">=4.5.0"
-  },
   "dependencies": {
-    "@openapi-spec/types": "~0.6.0",
-    "@orpc/json-schema": "2.0.0-beta.48"
+    "@orpc/json-schema": "2.0.0-beta.49"
   },
   "devDependencies": {
     "zod": "^4.6.7"
   },
-  "scripts": {
-    "type:check": "tsc -b"
-  }
+  "peerDependencies": {
+    "zod": ">=4.5.0"
+  },
+  "scripts": {}
 }

package/dist/converter.d.mts

@@ -1,30 +0,0 @@
-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;
-}
-/**
-* 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 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;
-}

package/dist/converter.mjs

@@ -1,118 +0,0 @@
-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.mjs";
-
-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);
-			}
-		});
-		
-		
-		const { $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
-		};
-	}
-}
-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
-			};
-		}
-	}
-}

package/dist/index.d.mts

@@ -1,3 +0,0 @@
-export * from "./converter.mjs";
-export * from "./registries.mjs";
-export type { JsonSchema } from "@orpc/json-schema";

package/dist/index.mjs

@@ -1,2 +0,0 @@
-export * from "./converter.mjs";
-export * from "./registries.mjs";

package/dist/registries.d.mts

@@ -1,62 +0,0 @@
-import type { JsonSchema } from "@orpc/json-schema";
-import type { $input, $output, $ZodRegistry } from "zod/v4/core";
-/**
-* 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 declare const JSON_SCHEMA_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$input | $output>, boolean>>;
-/**
-* 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 declare const JSON_SCHEMA_INPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$input>, boolean>>;
-/**
-* 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 declare const JSON_SCHEMA_OUTPUT_REGISTRY: $ZodRegistry<Exclude<JsonSchema<$output>, boolean>>;

package/dist/registries.mjs

@@ -1,7 +0,0 @@
-import { registry } from "zod/v4/core";
-
-export const JSON_SCHEMA_REGISTRY = /* @__PURE__ */ registry();
-
-export const JSON_SCHEMA_INPUT_REGISTRY = /* @__PURE__ */ registry();
-
-export const JSON_SCHEMA_OUTPUT_REGISTRY = /* @__PURE__ */ registry();