npm - @orpc/zod - Versions diffs - 0.0.0-next.cac5dd3 → 0.0.0-next.caeb672 - Mend

@orpc/zod 0.0.0-next.cac5dd3 → 0.0.0-next.caeb672

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md CHANGED Viewed

@@ -30,7 +30,7 @@
 - **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
 - **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
 - **📝 Contract-First Development**: Optionally define your API contract before implementation.
-- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), Pinia Colada, and more.
 - **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
 - **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
 - **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
@@ -49,14 +49,12 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
-- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with NestJS.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
-- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
-- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
-- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
-- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
 - [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
-- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
 - [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
 - [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
@@ -74,7 +72,7 @@ More schemas that [Zod](https://zod.dev/) doesn't support yet, and provides `Zod
 ```ts
 import { oz } from '@orpc/zod'
-import { z } from 'zod'
+import { z } from 'zod/v3'
 const Example = z.object({
   url: oz.url(),
@@ -88,7 +86,7 @@ const Example = z.object({
 ```ts
 import { OpenAPIGenerator } from '@orpc/openapi'
-import { ZodToJsonSchemaConverter } from '@orpc/zod'
+import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4'
 const openAPIGenerator = new OpenAPIGenerator({
   schemaConverters: [new ZodToJsonSchemaConverter()],
@@ -113,7 +111,7 @@ const specFromRouter = await openAPIGenerator.generate(router, {
 ```ts
 import { oz } from '@orpc/zod'
-import { z } from 'zod'
+import * as z from 'zod'
 const InputSchema = oz.openapi(
   z.object({

package/dist/index.d.mts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
-import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod';
+import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod/v3';
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
@@ -40,34 +40,43 @@ declare class ZodSmartCoercionPlugin<TContext extends Context> implements Standa
 interface ZodToJsonSchemaOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type
      *
-     * Used `{}` when reach max depth
+     * Used `{}` when exceed max depth
      *
      * @default 3
      */
     maxLazyDepth?: number;
     /**
-     * The schema to be used when the Zod schema is unsupported.
+     * Max depth of nested types
      *
-     * @default { not: {} }
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
      */
-    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
      * @default { }
      */
     anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
 }
 declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly unsupportedJsonSchema;
     private readonly anyJsonSchema;
     constructor(options?: ZodToJsonSchemaOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean, structureDepth?: number): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 declare const oz: {

package/dist/index.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { JSONSchema, ConditionalSchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
-import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod';
+import { ZodTypeAny, input, output, ZodTypeDef, CustomErrorParams, ZodType, ZodEffects } from 'zod/v3';
 import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
@@ -40,34 +40,43 @@ declare class ZodSmartCoercionPlugin<TContext extends Context> implements Standa
 interface ZodToJsonSchemaOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type
      *
-     * Used `{}` when reach max depth
+     * Used `{}` when exceed max depth
      *
      * @default 3
      */
     maxLazyDepth?: number;
     /**
-     * The schema to be used when the Zod schema is unsupported.
+     * Max depth of nested types
      *
-     * @default { not: {} }
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
      */
-    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
      * @default { }
      */
     anyJsonSchema?: Exclude<JSONSchema, boolean>;
+    /**
+     * The schema to be used when the Zod schema is unsupported.
+     *
+     * @default { not: {} }
+     */
+    unsupportedJsonSchema?: Exclude<JSONSchema, boolean>;
 }
 declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly unsupportedJsonSchema;
     private readonly anyJsonSchema;
     constructor(options?: ZodToJsonSchemaOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions, lazyDepth?: number, isHandledCustomJSONSchema?: boolean, isHandledZodDescription?: boolean, structureDepth?: number): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 declare const oz: {

package/dist/index.mjs CHANGED Viewed

@@ -1,6 +1,7 @@
-import { custom, ZodFirstPartyTypeKind } from 'zod';
+import { custom, ZodFirstPartyTypeKind } from 'zod/v3';
 import wcmatch from 'wildcard-match';
-import { isObject, guard } from '@orpc/shared';
+import { isObject, guard, toArray } from '@orpc/shared';
+import { JsonSchemaXNativeType } from '@orpc/json-schema';
 import { JSONSchemaFormat } from '@orpc/openapi';
 import escapeStringRegexp from 'escape-string-regexp';
@@ -128,7 +129,7 @@ class ZodSmartCoercionPlugin {
     options.clientInterceptors ??= [];
     options.clientInterceptors.unshift((options2) => {
       const inputSchema = options2.procedure["~orpc"].inputSchema;
-      if (!inputSchema || inputSchema["~standard"].vendor !== "zod") {
+      if (!inputSchema || inputSchema["~standard"].vendor !== "zod" || "_zod" in inputSchema) {
         return options2.next();
       }
       const coercedInput = zodCoerceInternal(inputSchema, options2.input);
@@ -390,25 +391,39 @@ function safeToDate(value) {
 class ZodToJsonSchemaConverter {
   maxLazyDepth;
+  maxStructureDepth;
   unsupportedJsonSchema;
   anyJsonSchema;
   constructor(options = {}) {
     this.maxLazyDepth = options.maxLazyDepth ?? 3;
+    this.maxStructureDepth = options.maxStructureDepth ?? 10;
     this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
     this.anyJsonSchema = options.anyJsonSchema ?? {};
   }
   condition(schema) {
-    return schema !== void 0 && schema["~standard"].vendor === "zod";
+    return schema !== void 0 && schema["~standard"].vendor === "zod" && !("_zod" in schema);
   }
-  convert(schema, options, lazyDepth = 0, isHandledCustomJSONSchema = false, isHandledZodDescription = false) {
+  convert(schema, options, lazyDepth = 0, isHandledCustomJSONSchema = false, isHandledZodDescription = false, structureDepth = 0) {
     const def = schema._def;
+    if (structureDepth > this.maxStructureDepth) {
+      return [false, this.anyJsonSchema];
+    }
+    if (!options.minStructureDepthForRef || options.minStructureDepthForRef <= structureDepth) {
+      const components = toArray(options.components);
+      for (const component of components) {
+        if (component.schema === schema && component.allowedStrategies.includes(options.strategy)) {
+          return [component.required, { $ref: component.ref }];
+        }
+      }
+    }
     if (!isHandledZodDescription && "description" in def && typeof def.description === "string") {
       const [required, json] = this.convert(
         schema,
         options,
         lazyDepth,
         isHandledCustomJSONSchema,
-        true
+        true,
+        structureDepth
       );
       return [required, { ...json, description: def.description }];
     }
@@ -420,7 +435,8 @@ class ZodToJsonSchemaConverter {
           options,
           lazyDepth,
           true,
-          isHandledZodDescription
+          isHandledZodDescription,
+          structureDepth
         );
         return [required, { ...json, ...customJSONSchema }];
       }
@@ -548,7 +564,11 @@ class ZodToJsonSchemaConverter {
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodBigInt: {
-        const json = { type: "string", pattern: "^-?[0-9]+$" };
+        const json = {
+          "type": "string",
+          "pattern": "^-?[0-9]+$",
+          "x-native-type": JsonSchemaXNativeType.BigInt
+        };
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodNaN: {
@@ -558,7 +578,11 @@ class ZodToJsonSchemaConverter {
         return [true, { type: "boolean" }];
       }
       case ZodFirstPartyTypeKind.ZodDate: {
-        const schema2 = { type: "string", format: JSONSchemaFormat.DateTime };
+        const schema2 = {
+          "type": "string",
+          "format": JSONSchemaFormat.DateTime,
+          "x-native-type": JsonSchemaXNativeType.Date
+        };
         return [true, schema2];
       }
       case ZodFirstPartyTypeKind.ZodNull: {
@@ -591,7 +615,7 @@ class ZodToJsonSchemaConverter {
         const schema_ = schema;
         const def2 = schema_._def;
         const json = { type: "array" };
-        const [itemRequired, itemJson] = this.convert(def2.type, options, lazyDepth, false, false);
+        const [itemRequired, itemJson] = this.convert(def2.type, options, lazyDepth, false, false, structureDepth + 1);
         json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
         if (def2.exactLength) {
           json.maxItems = def2.exactLength.value;
@@ -610,7 +634,7 @@ class ZodToJsonSchemaConverter {
         const prefixItems = [];
         const json = { type: "array" };
         for (const item of schema_._def.items) {
-          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth + 1);
           prefixItems.push(
             this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy)
           );
@@ -619,7 +643,7 @@ class ZodToJsonSchemaConverter {
           json.prefixItems = prefixItems;
         }
         if (schema_._def.rest) {
-          const [itemRequired, itemJson] = this.convert(schema_._def.rest, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(schema_._def.rest, options, lazyDepth, false, false, structureDepth + 1);
           json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
         }
         return [true, json];
@@ -630,7 +654,7 @@ class ZodToJsonSchemaConverter {
         const properties = {};
         const required = [];
         for (const [key, value] of Object.entries(schema_.shape)) {
-          const [itemRequired, itemJson] = this.convert(value, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(value, options, lazyDepth, false, false, structureDepth + 1);
           properties[key] = itemJson;
           if (itemRequired) {
             required.push(key);
@@ -648,7 +672,7 @@ class ZodToJsonSchemaConverter {
             json.additionalProperties = false;
           }
         } else {
-          const [_, addJson] = this.convert(schema_._def.catchall, options, lazyDepth, false, false);
+          const [_, addJson] = this.convert(schema_._def.catchall, options, lazyDepth, false, false, structureDepth + 1);
           json.additionalProperties = addJson;
         }
         return [true, json];
@@ -656,28 +680,32 @@ class ZodToJsonSchemaConverter {
       case ZodFirstPartyTypeKind.ZodRecord: {
         const schema_ = schema;
         const json = { type: "object" };
-        const [__, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false);
+        const [__, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false, structureDepth + 1);
         if (Object.entries(keyJson).some(([k, v]) => k !== "type" || v !== "string")) {
           json.propertyNames = keyJson;
         }
-        const [_, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false);
+        const [_, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false, structureDepth + 1);
         json.additionalProperties = itemJson;
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodSet: {
         const schema_ = schema;
-        const json = { type: "array", uniqueItems: true };
-        const [itemRequired, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false);
+        const json = {
+          "type": "array",
+          "uniqueItems": true,
+          "x-native-type": JsonSchemaXNativeType.Set
+        };
+        const [itemRequired, itemJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false, structureDepth + 1);
         json.items = this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy);
         return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodMap: {
         const schema_ = schema;
-        const [keyRequired, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false);
-        const [valueRequired, valueJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false);
-        return [true, {
-          type: "array",
-          items: {
+        const [keyRequired, keyJson] = this.convert(schema_._def.keyType, options, lazyDepth, false, false, structureDepth + 1);
+        const [valueRequired, valueJson] = this.convert(schema_._def.valueType, options, lazyDepth, false, false, structureDepth + 1);
+        const json = {
+          "type": "array",
+          "items": {
             type: "array",
             prefixItems: [
               this.#toArrayItemJsonSchema(keyRequired, keyJson, options.strategy),
@@ -685,8 +713,10 @@ class ZodToJsonSchemaConverter {
             ],
             maxItems: 2,
             minItems: 2
-          }
-        }];
+          },
+          "x-native-type": JsonSchemaXNativeType.Map
+        };
+        return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodUnion:
       case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
@@ -694,7 +724,7 @@ class ZodToJsonSchemaConverter {
         const anyOf = [];
         let required = true;
         for (const item of schema_._def.options) {
-          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth);
           if (!itemRequired) {
             required = false;
             if (itemJson !== this.unsupportedJsonSchema) {
@@ -714,7 +744,7 @@ class ZodToJsonSchemaConverter {
         const allOf = [];
         let required = false;
         for (const item of [schema_._def.left, schema_._def.right]) {
-          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth);
           allOf.push(itemJson);
           if (itemRequired) {
             required = true;
@@ -723,25 +753,26 @@ class ZodToJsonSchemaConverter {
         return [required, { allOf }];
       }
       case ZodFirstPartyTypeKind.ZodLazy: {
-        if (lazyDepth >= this.maxLazyDepth) {
+        const currentLazyDepth = lazyDepth + 1;
+        if (currentLazyDepth > this.maxLazyDepth) {
           return [false, this.anyJsonSchema];
         }
         const schema_ = schema;
-        return this.convert(schema_._def.getter(), options, lazyDepth + 1, false, false);
+        return this.convert(schema_._def.getter(), options, currentLazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodOptional: {
         const schema_ = schema;
-        const [_, inner] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        const [_, inner] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [false, inner];
       }
       case ZodFirstPartyTypeKind.ZodReadonly: {
         const schema_ = schema;
-        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [required, { ...json, readOnly: true }];
       }
       case ZodFirstPartyTypeKind.ZodDefault: {
         const schema_ = schema;
-        const [_, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        const [_, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [false, { default: schema_._def.defaultValue(), ...json }];
       }
       case ZodFirstPartyTypeKind.ZodEffects: {
@@ -749,15 +780,15 @@ class ZodToJsonSchemaConverter {
         if (schema_._def.effect.type === "transform" && options.strategy === "output") {
           return [false, this.anyJsonSchema];
         }
-        return this.convert(schema_._def.schema, options, lazyDepth, false, false);
+        return this.convert(schema_._def.schema, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodCatch: {
         const schema_ = schema;
-        return this.convert(schema_._def.innerType, options, lazyDepth, false, false);
+        return this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodBranded: {
         const schema_ = schema;
-        return this.convert(schema_._def.type, options, lazyDepth, false, false);
+        return this.convert(schema_._def.type, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodPipeline: {
         const schema_ = schema;
@@ -766,13 +797,14 @@ class ZodToJsonSchemaConverter {
           options,
           lazyDepth,
           false,
-          false
+          false,
+          structureDepth
         );
       }
       case ZodFirstPartyTypeKind.ZodNullable: {
         const schema_ = schema;
-        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false);
-        return [required, { anyOf: [{ type: "null" }, json] }];
+        const [required, json] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
+        return [required, { anyOf: [json, { type: "null" }] }];
       }
     }
     return [true, this.unsupportedJsonSchema];
@@ -791,12 +823,17 @@ class ZodToJsonSchemaConverter {
       }
       case "regexp": {
         return {
-          type: "string",
-          pattern: "^\\/(.*)\\/([a-z]*)$"
+          "type": "string",
+          "pattern": "^\\/(.*)\\/([a-z]*)$",
+          "x-native-type": JsonSchemaXNativeType.RegExp
         };
       }
       case "url": {
-        return { type: "string", format: JSONSchemaFormat.URI };
+        return {
+          "type": "string",
+          "format": JSONSchemaFormat.URI,
+          "x-native-type": JsonSchemaXNativeType.Url
+        };
       }
     }
   }

package/dist/zod4/index.d.mts CHANGED Viewed

@@ -2,24 +2,35 @@ import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
 import { JSONSchema, SchemaConvertOptions, ConditionalSchemaConverter } from '@orpc/openapi';
-import { Interceptor, ThrowableError, Promisable } from '@orpc/shared';
-import * as _zod_core from '@zod/core';
-import { $ZodType, $input, $output } from '@zod/core';
+import { Interceptor } from '@orpc/shared';
+import * as zod_v4_core from 'zod/v4/core';
+import { $ZodType, $input, $output } from 'zod/v4/core';
+/**
+ * @deprecated Use [Smart Coercion Plugin](https://orpc.unnoq.com/docs/openapi/plugins/smart-coercion) instead.
+ */
 declare class experimental_ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
     #private;
     init(options: StandardHandlerOptions<TContext>): void;
 }
-interface experimental_ZodToJsonSchemaOptions {
+interface ZodToJsonSchemaConverterOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type.
      *
-     * Used anyJsonSchema (`{}`) when reach max depth
+     * Used anyJsonSchema (`{}`) when exceed max depth
      *
      * @default 2
      */
     maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
@@ -46,18 +57,19 @@ interface experimental_ZodToJsonSchemaOptions {
     }, [
         required: boolean,
         jsonSchema: Exclude<JSONSchema, boolean>
-    ], ThrowableError>[];
+    ]>[];
 }
-declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
+declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly anyJsonSchema;
     private readonly unsupportedJsonSchema;
     private readonly undefinedJsonSchema;
     private readonly interceptors;
-    constructor(options?: experimental_ZodToJsonSchemaOptions);
+    constructor(options?: ZodToJsonSchemaConverterOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: Exclude<JSONSchema, boolean>]>;
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 /**
@@ -77,7 +89,7 @@ declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchema
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
+declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -138,7 +150,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, _zod_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -156,7 +168,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
+declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -217,7 +229,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, _zod_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -235,7 +247,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: _zod_core.$ZodRegistry<{
+declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -296,7 +308,7 @@ declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: _zod_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, _zod_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };
-export type { experimental_ZodToJsonSchemaOptions };
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };
+export type { ZodToJsonSchemaConverterOptions };

package/dist/zod4/index.d.ts CHANGED Viewed

@@ -2,24 +2,35 @@ import { Context } from '@orpc/server';
 import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
 import { AnySchema } from '@orpc/contract';
 import { JSONSchema, SchemaConvertOptions, ConditionalSchemaConverter } from '@orpc/openapi';
-import { Interceptor, ThrowableError, Promisable } from '@orpc/shared';
-import * as _zod_core from '@zod/core';
-import { $ZodType, $input, $output } from '@zod/core';
+import { Interceptor } from '@orpc/shared';
+import * as zod_v4_core from 'zod/v4/core';
+import { $ZodType, $input, $output } from 'zod/v4/core';
+/**
+ * @deprecated Use [Smart Coercion Plugin](https://orpc.unnoq.com/docs/openapi/plugins/smart-coercion) instead.
+ */
 declare class experimental_ZodSmartCoercionPlugin<TContext extends Context> implements StandardHandlerPlugin<TContext> {
     #private;
     init(options: StandardHandlerOptions<TContext>): void;
 }
-interface experimental_ZodToJsonSchemaOptions {
+interface ZodToJsonSchemaConverterOptions {
     /**
-     * Max depth of lazy type, if it exceeds.
+     * Max depth of lazy type.
      *
-     * Used anyJsonSchema (`{}`) when reach max depth
+     * Used anyJsonSchema (`{}`) when exceed max depth
      *
      * @default 2
      */
     maxLazyDepth?: number;
+    /**
+     * Max depth of nested types.
+     *
+     * Used anyJsonSchema (`{}`) when exceed max depth
+     *
+     * @default 10
+     */
+    maxStructureDepth?: number;
     /**
      * The schema to be used to represent the any | unknown type.
      *
@@ -46,18 +57,19 @@ interface experimental_ZodToJsonSchemaOptions {
     }, [
         required: boolean,
         jsonSchema: Exclude<JSONSchema, boolean>
-    ], ThrowableError>[];
+    ]>[];
 }
-declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
+declare class ZodToJsonSchemaConverter implements ConditionalSchemaConverter {
     #private;
     private readonly maxLazyDepth;
+    private readonly maxStructureDepth;
     private readonly anyJsonSchema;
     private readonly unsupportedJsonSchema;
     private readonly undefinedJsonSchema;
     private readonly interceptors;
-    constructor(options?: experimental_ZodToJsonSchemaOptions);
+    constructor(options?: ZodToJsonSchemaConverterOptions);
     condition(schema: AnySchema | undefined): boolean;
-    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: Exclude<JSONSchema, boolean>]>;
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): [required: boolean, jsonSchema: Exclude<JSONSchema, boolean>];
 }
 /**
@@ -77,7 +89,7 @@ declare class experimental_ZodToJsonSchemaConverter implements ConditionalSchema
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
+declare const JSON_SCHEMA_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -138,7 +150,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, _zod_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -156,7 +168,7 @@ declare const experimental_JSON_SCHEMA_REGISTRY: _zod_core.$ZodRegistry<{
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
+declare const JSON_SCHEMA_INPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -217,7 +229,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, _zod_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
 /**
  * Zod registry for customizing generated JSON schema, only useful for .input
  *
@@ -235,7 +247,7 @@ declare const experimental_JSON_SCHEMA_INPUT_REGISTRY: _zod_core.$ZodRegistry<{
  * })
  * ```
  */
-declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: _zod_core.$ZodRegistry<{
+declare const JSON_SCHEMA_OUTPUT_REGISTRY: zod_v4_core.$ZodRegistry<{
     $anchor?: string;
     $comment?: string;
     $defs?: Record<string, JSONSchema>;
@@ -296,7 +308,7 @@ declare const experimental_JSON_SCHEMA_OUTPUT_REGISTRY: _zod_core.$ZodRegistry<{
     unevaluatedProperties?: JSONSchema;
     uniqueItems?: boolean;
     writeOnly?: boolean;
-}, _zod_core.$ZodType<unknown, unknown>>;
+}, zod_v4_core.$ZodType<unknown, unknown, zod_v4_core.$ZodTypeInternals<unknown, unknown>>>;
-export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };
-export type { experimental_ZodToJsonSchemaOptions };
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };
+export type { ZodToJsonSchemaConverterOptions };

package/dist/zod4/index.mjs CHANGED Viewed

@@ -1,13 +1,14 @@
-import { isObject, guard, intercept } from '@orpc/shared';
+import { isObject, guard, intercept, toArray } from '@orpc/shared';
+import { JsonSchemaXNativeType } from '@orpc/json-schema';
 import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@orpc/openapi';
-import { registry, globalRegistry } from '@zod/core';
+import { registry, globalRegistry } from 'zod/v4/core';
 class experimental_ZodSmartCoercionPlugin {
   init(options) {
     options.clientInterceptors ??= [];
     options.clientInterceptors.unshift((options2) => {
       const inputSchema = options2.procedure["~orpc"].inputSchema;
-      if (!inputSchema || inputSchema["~standard"].vendor !== "zod") {
+      if (!inputSchema || inputSchema["~standard"].vendor !== "zod" || !("_zod" in inputSchema)) {
         return options2.next();
       }
       const coercedInput = this.#coerce(inputSchema, options2.input);
@@ -100,8 +101,7 @@ class experimental_ZodSmartCoercionPlugin {
         }
         return value;
       }
-      case "object":
-      case "interface": {
+      case "object": {
         const object = schema;
         if (value === void 0) {
           return {};
@@ -165,9 +165,21 @@ class experimental_ZodSmartCoercionPlugin {
           return this.#coerce(union._zod.def.options[0], value);
         }
         if (isObject(value)) {
+          const discriminator = "discriminator" in union._zod.def && typeof union._zod.def.discriminator === "string" ? union._zod.def.discriminator : void 0;
           for (const option of union._zod.def.options) {
-            if (option._zod.disc && this.#matchDiscriminators(value, option._zod.disc)) {
-              return this.#coerce(option, value);
+            if (!option._zod.propValues) {
+              continue;
+            }
+            if (discriminator !== void 0) {
+              if (option._zod.propValues[discriminator]?.has(value[discriminator])) {
+                return this.#coerce(option, value);
+              }
+            } else {
+              for (const key in option._zod.propValues) {
+                if (option._zod.propValues[key]?.has(value[key])) {
+                  return this.#coerce(option, value);
+                }
+              }
             }
           }
         }
@@ -207,10 +219,17 @@ class experimental_ZodSmartCoercionPlugin {
         return this.#coerce(pipe._zod.def.in, value);
       }
       case "default":
-      case "catch": {
+      case "prefault": {
         const default_ = schema;
+        if (value === void 0) {
+          return value;
+        }
         return this.#coerce(default_._zod.def.innerType, value);
       }
+      case "catch": {
+        const catch_ = schema;
+        return this.#coerce(catch_._zod.def.innerType, value);
+      }
       case "lazy": {
         const lazy = schema;
         if (value !== void 0) {
@@ -248,64 +267,53 @@ class experimental_ZodSmartCoercionPlugin {
     }
     return value;
   }
-  /**
-   * This function is inspired from Zod, because it's not exported
-   * https://github.com/colinhacks/zod/blob/v4/packages/core/src/schemas.ts#L1903C1-L1921C2
-   */
-  #matchDiscriminators(input, discs) {
-    for (const [key, value] of discs) {
-      const data = input[key];
-      if (value.values.size && !value.values.has(data)) {
-        return false;
-      }
-      if (value.maps.length === 0) {
-        continue;
-      }
-      if (!isObject(data)) {
-        return false;
-      }
-      for (const m of value.maps) {
-        if (!this.#matchDiscriminators(data, m)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
 }
-const experimental_JSON_SCHEMA_REGISTRY = registry();
-const experimental_JSON_SCHEMA_INPUT_REGISTRY = registry();
-const experimental_JSON_SCHEMA_OUTPUT_REGISTRY = registry();
+const JSON_SCHEMA_REGISTRY = registry();
+const JSON_SCHEMA_INPUT_REGISTRY = registry();
+const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
-class experimental_ZodToJsonSchemaConverter {
+class ZodToJsonSchemaConverter {
   maxLazyDepth;
+  maxStructureDepth;
   anyJsonSchema;
   unsupportedJsonSchema;
   undefinedJsonSchema;
   interceptors;
   constructor(options = {}) {
     this.maxLazyDepth = options.maxLazyDepth ?? 2;
+    this.maxStructureDepth = options.maxStructureDepth ?? 10;
     this.anyJsonSchema = options.anyJsonSchema ?? {};
     this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
     this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
     this.interceptors = options.interceptors ?? [];
   }
   condition(schema) {
-    return schema !== void 0 && schema["~standard"].vendor === "zod";
+    return schema !== void 0 && schema["~standard"].vendor === "zod" && "_zod" in schema;
   }
   convert(schema, options) {
-    return this.#convert(schema, options, 0);
+    return this.#convert(schema, options, 0, 0);
   }
-  #convert(schema, options, lazyDepth, isHandledCustomJSONSchema = false) {
+  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
     return intercept(
       this.interceptors,
       { schema, options, lazyDepth, isHandledCustomJSONSchema },
-      async ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
+      ({ schema: schema2, options: options2, lazyDepth: lazyDepth2, isHandledCustomJSONSchema: isHandledCustomJSONSchema2 }) => {
+        if (structureDepth > this.maxStructureDepth) {
+          return [false, this.anyJsonSchema];
+        }
+        if (!options2.minStructureDepthForRef || options2.minStructureDepthForRef <= structureDepth) {
+          const components = toArray(options2.components);
+          for (const component of components) {
+            if (component.schema === schema2 && component.allowedStrategies.includes(options2.strategy)) {
+              return [component.required, { $ref: component.ref }];
+            }
+          }
+        }
         if (!isHandledCustomJSONSchema2) {
           const customJSONSchema = this.#getCustomJsonSchema(schema2, options2);
           if (customJSONSchema) {
-            const [required, json] = await this.#convert(schema2, options2, lazyDepth2, true);
+            const [required, json] = this.#convert(schema2, options2, lazyDepth2, structureDepth, true);
             return [required, { ...json, ...customJSONSchema }];
           }
         }
@@ -313,21 +321,28 @@ class experimental_ZodToJsonSchemaConverter {
           case "string": {
             const string = schema2;
             const json = { type: "string" };
-            const { minimum, maximum, format, pattern, contentEncoding } = string._zod.computed;
-            if (minimum !== void 0) {
+            const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+            if (typeof minimum === "number") {
               json.minLength = minimum;
             }
-            if (maximum !== void 0) {
+            if (typeof maximum === "number") {
               json.maxLength = maximum;
             }
-            if (contentEncoding !== void 0) {
+            if (typeof contentEncoding === "string") {
               json.contentEncoding = this.#handleContentEncoding(contentEncoding);
             }
-            if (format !== void 0 && format !== "regex" && json.contentEncoding === void 0) {
+            if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
               json.format = this.#handleStringFormat(format);
             }
-            if (pattern !== void 0 && json.contentEncoding === void 0 && json.format === void 0) {
-              json.pattern = pattern.source;
+            if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
+              for (const pattern of patterns) {
+                if (json.pattern === void 0) {
+                  json.pattern = pattern.source;
+                } else {
+                  json.allOf ??= [];
+                  json.allOf.push({ pattern: pattern.source });
+                }
+              }
             }
             if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
               json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
@@ -337,25 +352,23 @@ class experimental_ZodToJsonSchemaConverter {
           case "number": {
             const number = schema2;
             const json = { type: "number" };
-            const { minimum, maximum, format, multipleOf, inclusive } = number._zod.computed;
-            if (format?.includes("int")) {
+            const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+            if (typeof format === "string" && format?.includes("int")) {
               json.type = "integer";
             }
-            if (minimum !== void 0) {
-              if (inclusive) {
-                json.minimum = minimum;
-              } else {
-                json.exclusiveMinimum = minimum;
-              }
+            if (typeof minimum === "number") {
+              json.minimum = minimum;
             }
-            if (maximum !== void 0) {
-              if (inclusive) {
-                json.maximum = maximum;
-              } else {
-                json.exclusiveMaximum = maximum;
-              }
+            if (typeof maximum === "number") {
+              json.maximum = maximum;
+            }
+            if (typeof exclusiveMinimum === "number") {
+              json.exclusiveMinimum = exclusiveMinimum;
             }
-            if (multipleOf !== void 0) {
+            if (typeof exclusiveMaximum === "number") {
+              json.exclusiveMaximum = exclusiveMaximum;
+            }
+            if (typeof multipleOf === "number") {
               json.multipleOf = multipleOf;
             }
             return [true, json];
@@ -364,10 +377,18 @@ class experimental_ZodToJsonSchemaConverter {
             return [true, { type: "boolean" }];
           }
           case "bigint": {
-            return [true, { type: "string", pattern: "^-?[0-9]+$" }];
+            return [true, {
+              "type": "string",
+              "pattern": "^-?[0-9]+$",
+              "x-native-type": JsonSchemaXNativeType.BigInt
+            }];
           }
           case "date": {
-            return [true, { type: "string", format: JSONSchemaFormat.DateTime }];
+            return [true, {
+              "type": "string",
+              "format": JSONSchemaFormat.DateTime,
+              "x-native-type": JsonSchemaXNativeType.Date
+            }];
           }
           case "null": {
             return [true, { type: "null" }];
@@ -388,21 +409,21 @@ class experimental_ZodToJsonSchemaConverter {
           case "array": {
             const array = schema2;
             const json = { type: "array" };
-            const { minimum, maximum } = array._zod.computed;
-            if (minimum !== void 0) {
+            const { minimum, maximum } = array._zod.bag;
+            if (typeof minimum === "number") {
               json.minItems = minimum;
             }
-            if (maximum !== void 0) {
+            if (typeof maximum === "number") {
               json.maxItems = maximum;
             }
-            json.items = this.#handleArrayItemJsonSchema(await this.#convert(array._zod.def.element, options2, lazyDepth2), options2);
+            json.items = this.#handleArrayItemJsonSchema(this.#convert(array._zod.def.element, options2, lazyDepth2, structureDepth + 1), options2);
             return [true, json];
           }
           case "object": {
             const object = schema2;
             const json = { type: "object" };
             for (const [key, value] of Object.entries(object._zod.def.shape)) {
-              const [itemRequired, itemJson] = await this.#convert(value, options2, lazyDepth2);
+              const [itemRequired, itemJson] = this.#convert(value, options2, lazyDepth2, structureDepth + 1);
               json.properties ??= {};
               json.properties[key] = itemJson;
               if (itemRequired) {
@@ -414,7 +435,7 @@ class experimental_ZodToJsonSchemaConverter {
               if (object._zod.def.catchall._zod.def.type === "never") {
                 json.additionalProperties = false;
               } else {
-                const [_, addJson] = await this.#convert(object._zod.def.catchall, options2, lazyDepth2);
+                const [_, addJson] = this.#convert(object._zod.def.catchall, options2, lazyDepth2, structureDepth + 1);
                 json.additionalProperties = addJson;
               }
             }
@@ -425,7 +446,7 @@ class experimental_ZodToJsonSchemaConverter {
             const anyOf = [];
             let required = true;
             for (const item of union._zod.def.options) {
-              const [itemRequired, itemJson] = await this.#convert(item, options2, lazyDepth2);
+              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
               if (!itemRequired) {
                 required = false;
               }
@@ -446,7 +467,7 @@ class experimental_ZodToJsonSchemaConverter {
             const json = { allOf: [] };
             let required = false;
             for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
-              const [itemRequired, itemJson] = await this.#convert(item, options2, lazyDepth2);
+              const [itemRequired, itemJson] = this.#convert(item, options2, lazyDepth2, structureDepth);
               json.allOf.push(itemJson);
               if (itemRequired) {
                 required = true;
@@ -458,16 +479,16 @@ class experimental_ZodToJsonSchemaConverter {
             const tuple = schema2;
             const json = { type: "array", prefixItems: [] };
             for (const item of tuple._zod.def.items) {
-              json.prefixItems.push(this.#handleArrayItemJsonSchema(await this.#convert(item, options2, lazyDepth2), options2));
+              json.prefixItems.push(this.#handleArrayItemJsonSchema(this.#convert(item, options2, lazyDepth2, structureDepth + 1), options2));
             }
             if (tuple._zod.def.rest) {
-              json.items = this.#handleArrayItemJsonSchema(await this.#convert(tuple._zod.def.rest, options2, lazyDepth2), options2);
+              json.items = this.#handleArrayItemJsonSchema(this.#convert(tuple._zod.def.rest, options2, lazyDepth2, structureDepth + 1), options2);
             }
-            const { minimum, maximum } = tuple._zod.computed;
-            if (minimum !== void 0) {
+            const { minimum, maximum } = tuple._zod.bag;
+            if (typeof minimum === "number") {
               json.minItems = minimum;
             }
-            if (maximum !== void 0) {
+            if (typeof maximum === "number") {
               json.maxItems = maximum;
             }
             return [true, json];
@@ -475,31 +496,33 @@ class experimental_ZodToJsonSchemaConverter {
           case "record": {
             const record = schema2;
             const json = { type: "object" };
-            json.propertyNames = (await this.#convert(record._zod.def.keyType, options2, lazyDepth2))[1];
-            json.additionalProperties = (await this.#convert(record._zod.def.valueType, options2, lazyDepth2))[1];
+            json.propertyNames = this.#convert(record._zod.def.keyType, options2, lazyDepth2, structureDepth + 1)[1];
+            json.additionalProperties = this.#convert(record._zod.def.valueType, options2, lazyDepth2, structureDepth + 1)[1];
             return [true, json];
           }
           case "map": {
             const map = schema2;
             return [true, {
-              type: "array",
-              items: {
+              "type": "array",
+              "items": {
                 type: "array",
                 prefixItems: [
-                  this.#handleArrayItemJsonSchema(await this.#convert(map._zod.def.keyType, options2, lazyDepth2), options2),
-                  this.#handleArrayItemJsonSchema(await this.#convert(map._zod.def.valueType, options2, lazyDepth2), options2)
+                  this.#handleArrayItemJsonSchema(this.#convert(map._zod.def.keyType, options2, lazyDepth2, structureDepth + 1), options2),
+                  this.#handleArrayItemJsonSchema(this.#convert(map._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2)
                 ],
                 maxItems: 2,
                 minItems: 2
-              }
+              },
+              "x-native-type": JsonSchemaXNativeType.Map
             }];
           }
           case "set": {
             const set = schema2;
             return [true, {
-              type: "array",
-              uniqueItems: true,
-              items: this.#handleArrayItemJsonSchema(await this.#convert(set._zod.def.valueType, options2, lazyDepth2), options2)
+              "type": "array",
+              "uniqueItems": true,
+              "items": this.#handleArrayItemJsonSchema(this.#convert(set._zod.def.valueType, options2, lazyDepth2, structureDepth + 1), options2),
+              "x-native-type": JsonSchemaXNativeType.Set
             }];
           }
           case "enum": {
@@ -523,12 +546,14 @@ class experimental_ZodToJsonSchemaConverter {
           case "file": {
             const file = schema2;
             const oneOf = [];
-            const { mime } = file._zod.computed;
-            for (const type of mime ?? ["*/*"]) {
-              oneOf.push({
-                type: "string",
-                contentMediaType: type
-              });
+            const { mime } = file._zod.bag;
+            if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
+              for (const type of mime ?? ["*/*"]) {
+                oneOf.push({
+                  type: "string",
+                  contentMediaType: type
+                });
+              }
             }
             return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
           }
@@ -537,40 +562,40 @@ class experimental_ZodToJsonSchemaConverter {
           }
           case "nullable": {
             const nullable = schema2;
-            const [required, json] = await this.#convert(nullable._zod.def.innerType, options2, lazyDepth2);
+            const [required, json] = this.#convert(nullable._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [required, { anyOf: [json, { type: "null" }] }];
           }
           case "nonoptional": {
             const nonoptional = schema2;
-            const [, json] = await this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2);
+            const [, json] = this.#convert(nonoptional._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [true, json];
           }
           case "success": {
             return [true, { type: "boolean" }];
           }
-          case "default": {
+          case "default":
+          case "prefault": {
             const default_ = schema2;
-            const [, json] = await this.#convert(default_._zod.def.innerType, options2, lazyDepth2);
+            const [, json] = this.#convert(default_._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [false, {
               ...json,
-              default: default_._zod.def.defaultValue()
+              default: default_._zod.def.defaultValue
             }];
           }
           case "catch": {
             const catch_ = schema2;
-            const [, json] = await this.#convert(catch_._zod.def.innerType, options2, lazyDepth2);
-            return [false, json];
+            return this.#convert(catch_._zod.def.innerType, options2, lazyDepth2, structureDepth);
           }
           case "nan": {
             return [true, options2.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
           }
           case "pipe": {
             const pipe = schema2;
-            return await this.#convert(options2.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out, options2, lazyDepth2);
+            return this.#convert(options2.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out, options2, lazyDepth2, structureDepth);
           }
           case "readonly": {
             const readonly_ = schema2;
-            const [required, json] = await this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2);
+            const [required, json] = this.#convert(readonly_._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [required, { ...json, readOnly: true }];
           }
           case "template_literal": {
@@ -582,15 +607,16 @@ class experimental_ZodToJsonSchemaConverter {
           }
           case "optional": {
             const optional = schema2;
-            const [, json] = await this.#convert(optional._zod.def.innerType, options2, lazyDepth2);
+            const [, json] = this.#convert(optional._zod.def.innerType, options2, lazyDepth2, structureDepth);
             return [false, json];
           }
           case "lazy": {
             const lazy = schema2;
-            if (lazyDepth2 >= this.maxLazyDepth) {
+            const currentLazyDepth = lazyDepth2 + 1;
+            if (currentLazyDepth > this.maxLazyDepth) {
               return [false, this.anyJsonSchema];
             }
-            return await this.#convert(lazy._zod.def.getter(), options2, lazyDepth2 + 1);
+            return this.#convert(lazy._zod.def.getter(), options2, currentLazyDepth, structureDepth);
           }
           default: {
             schema2._zod.def.type;
@@ -601,25 +627,26 @@ class experimental_ZodToJsonSchemaConverter {
     );
   }
   #getCustomJsonSchema(schema, options) {
-    if (options.strategy === "input" && experimental_JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
-      return experimental_JSON_SCHEMA_INPUT_REGISTRY.get(schema);
+    if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
     }
-    if (options.strategy === "output" && experimental_JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
-      return experimental_JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+    if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
     }
-    if (experimental_JSON_SCHEMA_REGISTRY.has(schema)) {
-      return experimental_JSON_SCHEMA_REGISTRY.get(schema);
+    if (JSON_SCHEMA_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_REGISTRY.get(schema);
     }
     const global = globalRegistry.get(schema);
     if (global) {
       return {
+        title: global.title,
         description: global.description,
-        examples: global.examples
+        examples: Array.isArray(global.examples) ? global.examples : void 0
       };
     }
   }
   #handleArrayItemJsonSchema([required, schema], options) {
-    if (required || options.strategy === "input") {
+    if (required || options.strategy === "input" || schema.default !== void 0) {
       return schema;
     }
     if (schema === this.undefinedJsonSchema) {
@@ -650,4 +677,4 @@ class experimental_ZodToJsonSchemaConverter {
   }
 }
-export { experimental_JSON_SCHEMA_INPUT_REGISTRY, experimental_JSON_SCHEMA_OUTPUT_REGISTRY, experimental_JSON_SCHEMA_REGISTRY, experimental_ZodSmartCoercionPlugin, experimental_ZodToJsonSchemaConverter };
+export { JSON_SCHEMA_INPUT_REGISTRY, JSON_SCHEMA_OUTPUT_REGISTRY, JSON_SCHEMA_REGISTRY, ZodToJsonSchemaConverter, experimental_ZodSmartCoercionPlugin };

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/zod",
   "type": "module",
-  "version": "0.0.0-next.cac5dd3",
+  "version": "0.0.0-next.caeb672",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,31 +29,19 @@
     "dist"
   ],
   "peerDependencies": {
-    "@zod/core": ">=0.11.4",
-    "zod": ">=3.24.2",
-    "@orpc/server": "0.0.0-next.cac5dd3",
-    "@orpc/contract": "0.0.0-next.cac5dd3"
-  },
-  "peerDependenciesMeta": {
-    "@zod/core": {
-      "optional": true
-    },
-    "zod": {
-      "optional": true
-    }
+    "zod": ">=3.25.0",
+    "@orpc/contract": "0.0.0-next.caeb672",
+    "@orpc/server": "0.0.0-next.caeb672"
   },
   "dependencies": {
     "escape-string-regexp": "^5.0.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/shared": "0.0.0-next.cac5dd3",
-    "@orpc/openapi": "0.0.0-next.cac5dd3"
+    "@orpc/json-schema": "0.0.0-next.caeb672",
+    "@orpc/shared": "0.0.0-next.caeb672",
+    "@orpc/openapi": "0.0.0-next.caeb672"
   },
   "devDependencies": {
-    "@zod/core": "^0.11.4",
-    "@zod/mini": "^4.0.0-beta.20250505T012514",
-    "zod": "^3.24.2",
-    "zod-to-json-schema": "^3.24.5",
-    "zod4": "npm:zod@^4.0.0-beta.20250505T012514"
+    "zod": "^4.0.5"
   },
   "scripts": {
     "build": "unbuild",