@orpc/zod 0.0.0-next.1431467 → 0.0.0-next.14dd190

package/dist/index.mjs

@@ -1,17 +1,18 @@
-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';
 
 const CUSTOM_JSON_SCHEMA_SYMBOL = Symbol("ORPC_CUSTOM_JSON_SCHEMA");
 const CUSTOM_JSON_SCHEMA_INPUT_SYMBOL = Symbol("ORPC_CUSTOM_JSON_SCHEMA_INPUT");
 const CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL = Symbol("ORPC_CUSTOM_JSON_SCHEMA_OUTPUT");
-function getCustomJsonSchema(def, strategy) {
-  if (strategy === "input" && CUSTOM_JSON_SCHEMA_INPUT_SYMBOL in def) {
+function getCustomJsonSchema(def, options) {
+  if (options.strategy === "input" && CUSTOM_JSON_SCHEMA_INPUT_SYMBOL in def) {
     return def[CUSTOM_JSON_SCHEMA_INPUT_SYMBOL];
   }
-  if (strategy === "output" && CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL in def) {
+  if (options.strategy === "output" && CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL in def) {
     return def[CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL];
   }
   if (CUSTOM_JSON_SCHEMA_SYMBOL in def) {
@@ -19,8 +20,8 @@ function getCustomJsonSchema(def, strategy) {
   }
   return void 0;
 }
-function customJsonSchema(schema, custom, strategy) {
-  const SYMBOL = strategy === "input" ? CUSTOM_JSON_SCHEMA_INPUT_SYMBOL : strategy === "output" ? CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL : CUSTOM_JSON_SCHEMA_SYMBOL;
+function customJsonSchema(schema, custom, options = {}) {
+  const SYMBOL = options.strategy === "input" ? CUSTOM_JSON_SCHEMA_INPUT_SYMBOL : options.strategy === "output" ? CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL : CUSTOM_JSON_SCHEMA_SYMBOL;
   const This = schema.constructor;
   const newSchema = new This({
     ...schema._def,
@@ -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,46 +391,61 @@ 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 Boolean(schema && schema["~standard"].vendor === "zod");
+    return schema !== void 0 && schema["~standard"].vendor === "zod" && !("_zod" in schema);
   }
-  convert(schema, strategy, 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,
-        strategy,
+        options,
         lazyDepth,
         isHandledCustomJSONSchema,
-        true
+        true,
+        structureDepth
       );
       return [required, { ...json, description: def.description }];
     }
     if (!isHandledCustomJSONSchema) {
-      const customJSONSchema = getCustomJsonSchema(def, strategy);
+      const customJSONSchema = getCustomJsonSchema(def, options);
       if (customJSONSchema) {
         const [required, json] = this.convert(
           schema,
-          strategy,
+          options,
           lazyDepth,
           true,
-          isHandledZodDescription
+          isHandledZodDescription,
+          structureDepth
         );
         return [required, { ...json, ...customJSONSchema }];
       }
     }
-    const customSchema = this.handleCustomZodDef(def);
+    const customSchema = this.#handleCustomZodDef(def);
     if (customSchema) {
       return [true, customSchema];
     }
-    const typeName = this.getZodTypeName(def);
+    const typeName = this.#getZodTypeName(def);
     switch (typeName) {
       case ZodFirstPartyTypeKind.ZodString: {
         const schema_ = schema;
@@ -548,17 +564,25 @@ 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: {
-        return strategy === "input" ? [true, this.unsupportedJsonSchema] : [true, { type: "null" }];
+        return options.strategy === "input" ? [true, this.unsupportedJsonSchema] : [true, { type: "null" }];
       }
       case ZodFirstPartyTypeKind.ZodBoolean: {
         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,8 +615,8 @@ class ZodToJsonSchemaConverter {
         const schema_ = schema;
         const def2 = schema_._def;
         const json = { type: "array" };
-        const [itemRequired, itemJson] = this.convert(def2.type, strategy, lazyDepth, false, false);
-        json.items = this.toArrayItemJsonSchema(itemRequired, itemJson, strategy);
+        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;
           json.minItems = def2.exactLength.value;
@@ -610,17 +634,17 @@ class ZodToJsonSchemaConverter {
         const prefixItems = [];
         const json = { type: "array" };
         for (const item of schema_._def.items) {
-          const [itemRequired, itemJson] = this.convert(item, strategy, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth + 1);
           prefixItems.push(
-            this.toArrayItemJsonSchema(itemRequired, itemJson, strategy)
+            this.#toArrayItemJsonSchema(itemRequired, itemJson, options.strategy)
           );
         }
         if (prefixItems?.length) {
           json.prefixItems = prefixItems;
         }
         if (schema_._def.rest) {
-          const [itemRequired, itemJson] = this.convert(schema_._def.rest, strategy, lazyDepth, false, false);
-          json.items = this.toArrayItemJsonSchema(itemRequired, itemJson, strategy);
+          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, strategy, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(value, options, lazyDepth, false, false, structureDepth + 1);
           properties[key] = itemJson;
           if (itemRequired) {
             required.push(key);
@@ -642,13 +666,13 @@ class ZodToJsonSchemaConverter {
         if (required.length) {
           json.required = required;
         }
-        const catchAllTypeName = this.getZodTypeName(schema_._def.catchall._def);
+        const catchAllTypeName = this.#getZodTypeName(schema_._def.catchall._def);
         if (catchAllTypeName === ZodFirstPartyTypeKind.ZodNever) {
           if (schema_._def.unknownKeys === "strict") {
             json.additionalProperties = false;
           }
         } else {
-          const [_, addJson] = this.convert(schema_._def.catchall, strategy, lazyDepth, false, false);
+          const [_, addJson] = this.convert(schema_._def.catchall, options, lazyDepth, false, false, structureDepth + 1);
           json.additionalProperties = addJson;
         }
         return [true, json];
@@ -656,33 +680,43 @@ class ZodToJsonSchemaConverter {
       case ZodFirstPartyTypeKind.ZodRecord: {
         const schema_ = schema;
         const json = { type: "object" };
-        const [_, itemJson] = this.convert(schema_._def.valueType, strategy, 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, 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, strategy, lazyDepth, false, false);
-        json.items = this.toArrayItemJsonSchema(itemRequired, itemJson, strategy);
+        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, strategy, lazyDepth, false, false);
-        const [valueRequired, valueJson] = this.convert(schema_._def.valueType, strategy, 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, strategy),
-              this.toArrayItemJsonSchema(valueRequired, valueJson, strategy)
+              this.#toArrayItemJsonSchema(keyRequired, keyJson, options.strategy),
+              this.#toArrayItemJsonSchema(valueRequired, valueJson, options.strategy)
             ],
             maxItems: 2,
             minItems: 2
-          }
-        }];
+          },
+          "x-native-type": JsonSchemaXNativeType.Map
+        };
+        return [true, json];
       }
       case ZodFirstPartyTypeKind.ZodUnion:
       case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
@@ -690,7 +724,7 @@ class ZodToJsonSchemaConverter {
         const anyOf = [];
         let required = true;
         for (const item of schema_._def.options) {
-          const [itemRequired, itemJson] = this.convert(item, strategy, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth);
           if (!itemRequired) {
             required = false;
             if (itemJson !== this.unsupportedJsonSchema) {
@@ -710,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, strategy, lazyDepth, false, false);
+          const [itemRequired, itemJson] = this.convert(item, options, lazyDepth, false, false, structureDepth);
           allOf.push(itemJson);
           if (itemRequired) {
             required = true;
@@ -719,60 +753,63 @@ 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(), strategy, 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, strategy, lazyDepth, false, false);
+        const [_, inner] = this.convert(schema_._def.innerType, options, lazyDepth, false, false, structureDepth);
         return [false, inner];
       }
       case ZodFirstPartyTypeKind.ZodReadonly: {
         const schema_ = schema;
-        return this.convert(schema_._def.innerType, strategy, 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, strategy, 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: {
         const schema_ = schema;
-        if (schema_._def.effect.type === "transform" && strategy === "output") {
+        if (schema_._def.effect.type === "transform" && options.strategy === "output") {
           return [false, this.anyJsonSchema];
         }
-        return this.convert(schema_._def.schema, strategy, 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, strategy, 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, strategy, lazyDepth, false, false);
+        return this.convert(schema_._def.type, options, lazyDepth, false, false, structureDepth);
       }
       case ZodFirstPartyTypeKind.ZodPipeline: {
         const schema_ = schema;
         return this.convert(
-          strategy === "input" ? schema_._def.in : schema_._def.out,
-          strategy,
+          options.strategy === "input" ? schema_._def.in : schema_._def.out,
+          options,
           lazyDepth,
           false,
-          false
+          false,
+          structureDepth
         );
       }
       case ZodFirstPartyTypeKind.ZodNullable: {
         const schema_ = schema;
-        const [required, json] = this.convert(schema_._def.innerType, strategy, 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];
   }
-  handleCustomZodDef(def) {
+  #handleCustomZodDef(def) {
     const customZodDef = getCustomZodDef(def);
     if (!customZodDef) {
       return void 0;
@@ -786,19 +823,24 @@ 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
+        };
       }
     }
   }
-  getZodTypeName(def) {
+  #getZodTypeName(def) {
     return def.typeName;
   }
-  toArrayItemJsonSchema(required, schema, strategy) {
+  #toArrayItemJsonSchema(required, schema, strategy) {
     if (required) {
       return schema;
     }