@orpc/zod 0.0.0-next.ee0aeaf → 0.0.0-next.f17a1a0

package/README.md

@@ -0,0 +1,132 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/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" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+
+---
+
+## Highlights
+
+- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
+- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
+- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
+- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
+- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
+- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
+- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
+- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
+- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
+- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
+- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
+- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
+- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
+- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@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/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/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/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+
+## `@orpc/zod`
+
+More schemas that [Zod](https://zod.dev/) doesn't support yet, and provides `ZodToJsonSchemaConverter` for generating OpenAPI specs.
+
+### More Schemas
+
+- `oz.url`: Zod schema for [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL) instance.
+- `oz.blob`: Zod schema for [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) instance.
+- `oz.file`: Zod schema for [File](https://developer.mozilla.org/en-US/docs/Web/API/File) instance.
+- `oz.regexp`: Zod schema for [RegExp](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp) instance.
+
+```ts
+import { oz } from '@orpc/zod'
+import { z } from 'zod'
+
+const Example = z.object({
+  url: oz.url(),
+  blob: oz.blob(),
+  file: oz.file().type('image/png'),
+  regexp: oz.regexp(),
+})
+```
+
+### Generate OpenAPI Spec
+
+```ts
+import { OpenAPIGenerator } from '@orpc/openapi'
+import { ZodToJsonSchemaConverter } from '@orpc/zod'
+
+const openAPIGenerator = new OpenAPIGenerator({
+  schemaConverters: [new ZodToJsonSchemaConverter()],
+})
+
+const specFromContract = await openAPIGenerator.generate(contract, {
+  info: {
+    title: 'My App',
+    version: '0.0.0',
+  },
+})
+
+const specFromRouter = await openAPIGenerator.generate(router, {
+  info: {
+    title: 'My App',
+    version: '0.0.0',
+  },
+})
+```
+
+### Extending the Specification
+
+```ts
+import { oz } from '@orpc/zod'
+import { z } from 'zod'
+
+const InputSchema = oz.openapi(
+  z.object({
+    name: z.string(),
+  }),
+  {
+    examples: [
+      { name: 'Earth' },
+      { name: 'Mars' },
+    ],
+    // additional options...
+  }
+)
+```
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.js

@@ -1,4 +1,367 @@
-// src/index.ts
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/escape-string-regexp@4.0.0/node_modules/escape-string-regexp/index.js
+var require_escape_string_regexp = __commonJS({
+  "../../node_modules/.pnpm/escape-string-regexp@4.0.0/node_modules/escape-string-regexp/index.js"(exports, module) {
+    "use strict";
+    module.exports = (string) => {
+      if (typeof string !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+    };
+  }
+});
+
+// src/coercer.ts
+import { guard, isObject } from "@orpc/shared";
+import {
+  ZodFirstPartyTypeKind
+} from "zod";
+var ZodSmartCoercionPlugin = class {
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.unshift((options2) => {
+      const inputSchema = options2.procedure["~orpc"].inputSchema;
+      if (!inputSchema || inputSchema["~standard"].vendor !== "zod") {
+        return options2.next();
+      }
+      const coercedInput = zodCoerceInternal(inputSchema, options2.input, { bracketNotation: true });
+      return options2.next({ ...options2, input: coercedInput });
+    });
+  }
+};
+function zodCoerceInternal(schema, value, options) {
+  const isRoot = options?.isRoot ?? true;
+  const options_ = { ...options, isRoot: false };
+  if (isRoot && options?.bracketNotation && Array.isArray(value) && value.length === 1) {
+    const newValue = zodCoerceInternal(schema, value[0], options_);
+    if (schema.safeParse(newValue).success) {
+      return newValue;
+    }
+    return zodCoerceInternal(schema, value, options_);
+  }
+  const customType = getCustomZodType(schema._def);
+  if (customType === "Invalid Date") {
+    if (typeof value === "string" && value.toLocaleLowerCase() === "invalid date") {
+      return /* @__PURE__ */ new Date("Invalid Date");
+    }
+  } else if (customType === "RegExp") {
+    if (typeof value === "string" && value.startsWith("/")) {
+      const match = value.match(/^\/(.*)\/([a-z]*)$/);
+      if (match) {
+        const [, pattern, flags] = match;
+        return new RegExp(pattern, flags);
+      }
+    }
+  } else if (customType === "URL") {
+    if (typeof value === "string") {
+      const url2 = guard(() => new URL(value));
+      if (url2 !== void 0) {
+        return url2;
+      }
+    }
+  }
+  if (schema._def.typeName === void 0) {
+    return value;
+  }
+  const typeName = schema._def.typeName;
+  if (typeName === ZodFirstPartyTypeKind.ZodNumber) {
+    if (options_?.bracketNotation && typeof value === "string") {
+      const num = Number(value);
+      if (!Number.isNaN(num)) {
+        return num;
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodNaN) {
+    if (typeof value === "string" && value.toLocaleLowerCase() === "nan") {
+      return Number.NaN;
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodBoolean) {
+    if (options_?.bracketNotation && typeof value === "string") {
+      const lower = value.toLowerCase();
+      if (lower === "false" || lower === "off" || lower === "f") {
+        return false;
+      }
+      if (lower === "true" || lower === "on" || lower === "t") {
+        return true;
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodNull) {
+    if (options_?.bracketNotation && typeof value === "string" && value.toLowerCase() === "null") {
+      return null;
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodUndefined || typeName === ZodFirstPartyTypeKind.ZodVoid) {
+    if (typeof value === "string" && value.toLowerCase() === "undefined") {
+      return void 0;
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodDate) {
+    if (typeof value === "string" && (value.includes("-") || value.includes(":") || value.toLocaleLowerCase() === "invalid date")) {
+      return new Date(value);
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodBigInt) {
+    if (typeof value === "string") {
+      const num = guard(() => BigInt(value));
+      if (num !== void 0) {
+        return num;
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodArray || typeName === ZodFirstPartyTypeKind.ZodTuple) {
+    const schema_ = schema;
+    if (Array.isArray(value)) {
+      return value.map((v) => zodCoerceInternal(schema_._def.type, v, options_));
+    }
+    if (options_?.bracketNotation) {
+      if (value === void 0) {
+        return [];
+      }
+      if (isObject(value) && Object.keys(value).every((k) => /^[1-9]\d*$/.test(k) || k === "0")) {
+        const indexes = Object.keys(value).map((k) => Number(k)).sort((a, b) => a - b);
+        const arr = Array.from({ length: (indexes.at(-1) ?? -1) + 1 });
+        for (const i of indexes) {
+          arr[i] = zodCoerceInternal(schema_._def.type, value[i], options_);
+        }
+        return arr;
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodObject) {
+    const schema_ = schema;
+    if (isObject(value)) {
+      const newObj = {};
+      const keys = /* @__PURE__ */ new Set([
+        ...Object.keys(value),
+        ...Object.keys(schema_.shape)
+      ]);
+      for (const k of keys) {
+        if (!(k in value))
+          continue;
+        const v = value[k];
+        newObj[k] = zodCoerceInternal(
+          schema_.shape[k] ?? schema_._def.catchall,
+          v,
+          options_
+        );
+      }
+      return newObj;
+    }
+    if (options_?.bracketNotation) {
+      if (value === void 0) {
+        return {};
+      }
+      if (Array.isArray(value) && value.length === 1) {
+        const emptySchema = schema_.shape[""] ?? schema_._def.catchall;
+        return { "": zodCoerceInternal(emptySchema, value[0], options_) };
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodSet) {
+    const schema_ = schema;
+    if (Array.isArray(value)) {
+      return new Set(
+        value.map((v) => zodCoerceInternal(schema_._def.valueType, v, options_))
+      );
+    }
+    if (options_?.bracketNotation) {
+      if (value === void 0) {
+        return /* @__PURE__ */ new Set();
+      }
+      if (isObject(value) && Object.keys(value).every((k) => /^[1-9]\d*$/.test(k) || k === "0")) {
+        const indexes = Object.keys(value).map((k) => Number(k)).sort((a, b) => a - b);
+        const arr = Array.from({ length: (indexes.at(-1) ?? -1) + 1 });
+        for (const i of indexes) {
+          arr[i] = zodCoerceInternal(schema_._def.valueType, value[i], options_);
+        }
+        return new Set(arr);
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodMap) {
+    const schema_ = schema;
+    if (Array.isArray(value) && value.every((i) => Array.isArray(i) && i.length === 2)) {
+      return new Map(
+        value.map(([k, v]) => [
+          zodCoerceInternal(schema_._def.keyType, k, options_),
+          zodCoerceInternal(schema_._def.valueType, v, options_)
+        ])
+      );
+    }
+    if (options_?.bracketNotation) {
+      if (value === void 0) {
+        return /* @__PURE__ */ new Map();
+      }
+      if (isObject(value)) {
+        const arr = Array.from({ length: Object.keys(value).length }).fill(void 0).map(
+          (_, i) => isObject(value[i]) && Object.keys(value[i]).length === 2 && "0" in value[i] && "1" in value[i] ? [value[i]["0"], value[i]["1"]] : void 0
+        );
+        if (arr.every((v) => !!v)) {
+          return new Map(
+            arr.map(([k, v]) => [
+              zodCoerceInternal(schema_._def.keyType, k, options_),
+              zodCoerceInternal(schema_._def.valueType, v, options_)
+            ])
+          );
+        }
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodRecord) {
+    const schema_ = schema;
+    if (isObject(value)) {
+      const newObj = {};
+      for (const [k, v] of Object.entries(value)) {
+        const key = zodCoerceInternal(schema_._def.keyType, k, options_);
+        const val = zodCoerceInternal(schema_._def.valueType, v, options_);
+        newObj[key] = val;
+      }
+      return newObj;
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodUnion || typeName === ZodFirstPartyTypeKind.ZodDiscriminatedUnion) {
+    const schema_ = schema;
+    if (schema_.safeParse(value).success) {
+      return value;
+    }
+    const results = [];
+    for (const s of schema_._def.options) {
+      const newValue = zodCoerceInternal(s, value, { ...options_, isRoot });
+      if (newValue === value)
+        continue;
+      const result = schema_.safeParse(newValue);
+      if (result.success) {
+        return newValue;
+      }
+      results.push([newValue, result.error.issues.length]);
+    }
+    if (results.length === 0) {
+      return value;
+    }
+    return results.sort((a, b) => a[1] - b[1])[0]?.[0];
+  } else if (typeName === ZodFirstPartyTypeKind.ZodIntersection) {
+    const schema_ = schema;
+    return zodCoerceInternal(
+      schema_._def.right,
+      zodCoerceInternal(schema_._def.left, value, { ...options_, isRoot }),
+      { ...options_, isRoot }
+    );
+  } else if (typeName === ZodFirstPartyTypeKind.ZodReadonly) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.innerType, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodPipeline) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.in, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodLazy) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.getter(), value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodEffects) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.schema, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodBranded) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.type, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodCatch) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.innerType, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodDefault) {
+    const schema_ = schema;
+    return zodCoerceInternal(schema_._def.innerType, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodNullable) {
+    const schema_ = schema;
+    if (value === null) {
+      return null;
+    }
+    if (typeof value === "string" && value.toLowerCase() === "null") {
+      return schema_.safeParse(value).success ? value : null;
+    }
+    return zodCoerceInternal(schema_._def.innerType, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodOptional) {
+    const schema_ = schema;
+    if (value === void 0) {
+      return void 0;
+    }
+    if (typeof value === "string" && value.toLowerCase() === "undefined") {
+      return schema_.safeParse(value).success ? value : void 0;
+    }
+    return zodCoerceInternal(schema_._def.innerType, value, { ...options_, isRoot });
+  } else if (typeName === ZodFirstPartyTypeKind.ZodNativeEnum) {
+    const schema_ = schema;
+    if (Object.values(schema_._def.values).includes(value)) {
+      return value;
+    }
+    if (options?.bracketNotation && typeof value === "string") {
+      for (const expectedValue of Object.values(schema_._def.values)) {
+        if (expectedValue.toString() === value) {
+          return expectedValue;
+        }
+      }
+    }
+  } else if (typeName === ZodFirstPartyTypeKind.ZodLiteral) {
+    const schema_ = schema;
+    const expectedValue = schema_._def.value;
+    if (typeof value === "string" && typeof expectedValue !== "string") {
+      if (typeof expectedValue === "bigint") {
+        const num = guard(() => BigInt(value));
+        if (num !== void 0) {
+          return num;
+        }
+      } else if (expectedValue === void 0) {
+        if (value.toLocaleLowerCase() === "undefined") {
+          return void 0;
+        }
+      } else if (options?.bracketNotation) {
+        if (typeof expectedValue === "number") {
+          const num = Number(value);
+          if (!Number.isNaN(num)) {
+            return num;
+          }
+        } else if (typeof expectedValue === "boolean") {
+          const lower = value.toLowerCase();
+          if (lower === "false" || lower === "off" || lower === "f") {
+            return false;
+          }
+          if (lower === "true" || lower === "on" || lower === "t") {
+            return true;
+          }
+        } else if (expectedValue === null) {
+          if (value.toLocaleLowerCase() === "null") {
+            return null;
+          }
+        }
+      }
+    }
+  } else {
+    const _expected = typeName;
+  }
+  return value;
+}
+
+// src/converter.ts
+var import_escape_string_regexp = __toESM(require_escape_string_regexp(), 1);
+import { JSONSchemaFormat } from "@orpc/openapi";
+import {
+  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
+} from "zod";
+
+// src/schemas.ts
 import wcmatch from "wildcard-match";
 import {
   custom
@@ -133,7 +496,475 @@ var oz = {
   regexp,
   url
 };
+
+// src/converter.ts
+var NON_LOGIC_KEYWORDS = [
+  // Core Documentation Keywords
+  "$anchor",
+  "$comment",
+  "$defs",
+  "$id",
+  "title",
+  "description",
+  // Value Keywords
+  "default",
+  "deprecated",
+  "examples",
+  // Metadata Keywords
+  "$schema",
+  "definitions",
+  // Legacy, but still used
+  "readOnly",
+  "writeOnly",
+  // Display and UI Hints
+  "contentMediaType",
+  "contentEncoding",
+  "format",
+  // Custom Extensions
+  "$vocabulary",
+  "$dynamicAnchor",
+  "$dynamicRef"
+];
+var UNSUPPORTED_JSON_SCHEMA = { not: {} };
+var UNDEFINED_JSON_SCHEMA = { const: "undefined" };
+function zodToJsonSchema(schema, options) {
+  if (schema["~standard"].vendor !== "zod") {
+    console.warn(`Generate JSON schema not support ${schema["~standard"].vendor} yet`);
+    return {};
+  }
+  const schema__ = schema;
+  if (!options?.isHandledZodDescription && "description" in schema__._def) {
+    const json = zodToJsonSchema(schema__, {
+      ...options,
+      isHandledZodDescription: true
+    });
+    return {
+      description: schema__._def.description,
+      ...json
+    };
+  }
+  if (!options?.isHandledCustomJSONSchema) {
+    const customJSONSchema = getCustomJSONSchema(schema__._def, options);
+    if (customJSONSchema) {
+      const json = zodToJsonSchema(schema__, {
+        ...options,
+        isHandledCustomJSONSchema: true
+      });
+      return {
+        ...json,
+        ...customJSONSchema
+      };
+    }
+  }
+  const childOptions = { ...options, isHandledCustomJSONSchema: false, isHandledZodDescription: false };
+  const customType = getCustomZodType(schema__._def);
+  switch (customType) {
+    case "Blob": {
+      return { type: "string", contentMediaType: "*/*" };
+    }
+    case "File": {
+      const mimeType = getCustomZodFileMimeType(schema__._def) ?? "*/*";
+      return { type: "string", contentMediaType: mimeType };
+    }
+    case "Invalid Date": {
+      return { const: "Invalid Date" };
+    }
+    case "RegExp": {
+      return {
+        type: "string",
+        pattern: "^\\/(.*)\\/([a-z]*)$"
+      };
+    }
+    case "URL": {
+      return { type: "string", format: JSONSchemaFormat.URI };
+    }
+  }
+  const _expectedCustomType = customType;
+  const typeName = schema__._def.typeName;
+  switch (typeName) {
+    case ZodFirstPartyTypeKind2.ZodString: {
+      const schema_ = schema__;
+      const json = { type: "string" };
+      for (const check of schema_._def.checks) {
+        switch (check.kind) {
+          case "base64":
+            json.contentEncoding = "base64";
+            break;
+          case "cuid":
+            json.pattern = "^[0-9A-HJKMNP-TV-Z]{26}$";
+            break;
+          case "email":
+            json.format = JSONSchemaFormat.Email;
+            break;
+          case "url":
+            json.format = JSONSchemaFormat.URI;
+            break;
+          case "uuid":
+            json.format = JSONSchemaFormat.UUID;
+            break;
+          case "regex":
+            json.pattern = check.regex.source;
+            break;
+          case "min":
+            json.minLength = check.value;
+            break;
+          case "max":
+            json.maxLength = check.value;
+            break;
+          case "length":
+            json.minLength = check.value;
+            json.maxLength = check.value;
+            break;
+          case "includes":
+            json.pattern = (0, import_escape_string_regexp.default)(check.value);
+            break;
+          case "startsWith":
+            json.pattern = `^${(0, import_escape_string_regexp.default)(check.value)}`;
+            break;
+          case "endsWith":
+            json.pattern = `${(0, import_escape_string_regexp.default)(check.value)}$`;
+            break;
+          case "emoji":
+            json.pattern = "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$";
+            break;
+          case "nanoid":
+            json.pattern = "^[a-zA-Z0-9_-]{21}$";
+            break;
+          case "cuid2":
+            json.pattern = "^[0-9a-z]+$";
+            break;
+          case "ulid":
+            json.pattern = "^[0-9A-HJKMNP-TV-Z]{26}$";
+            break;
+          case "datetime":
+            json.format = JSONSchemaFormat.DateTime;
+            break;
+          case "date":
+            json.format = JSONSchemaFormat.Date;
+            break;
+          case "time":
+            json.format = JSONSchemaFormat.Time;
+            break;
+          case "duration":
+            json.format = JSONSchemaFormat.Duration;
+            break;
+          case "ip":
+            json.format = JSONSchemaFormat.IPv4;
+            break;
+          case "jwt":
+            json.pattern = "^[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]+\\.[A-Za-z0-9-_]*$";
+            break;
+          case "base64url":
+            json.pattern = "^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$";
+            break;
+          default: {
+            const _expect = check.kind;
+          }
+        }
+      }
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodNumber: {
+      const schema_ = schema__;
+      const json = { type: "number" };
+      for (const check of schema_._def.checks) {
+        switch (check.kind) {
+          case "int":
+            json.type = "integer";
+            break;
+          case "min":
+            json.minimum = check.value;
+            break;
+          case "max":
+            json.maximum = check.value;
+            break;
+          case "multipleOf":
+            json.multipleOf = check.value;
+            break;
+          default: {
+            const _expect = check.kind;
+          }
+        }
+      }
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodNaN: {
+      return { const: "NaN" };
+    }
+    case ZodFirstPartyTypeKind2.ZodBigInt: {
+      const json = { type: "string", pattern: "^-?[0-9]+$" };
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodBoolean: {
+      return { type: "boolean" };
+    }
+    case ZodFirstPartyTypeKind2.ZodDate: {
+      const schema2 = { type: "string", format: JSONSchemaFormat.Date };
+      return schema2;
+    }
+    case ZodFirstPartyTypeKind2.ZodNull: {
+      return { type: "null" };
+    }
+    case ZodFirstPartyTypeKind2.ZodVoid:
+    case ZodFirstPartyTypeKind2.ZodUndefined: {
+      return UNDEFINED_JSON_SCHEMA;
+    }
+    case ZodFirstPartyTypeKind2.ZodLiteral: {
+      const schema_ = schema__;
+      return { const: schema_._def.value };
+    }
+    case ZodFirstPartyTypeKind2.ZodEnum: {
+      const schema_ = schema__;
+      return {
+        enum: schema_._def.values
+      };
+    }
+    case ZodFirstPartyTypeKind2.ZodNativeEnum: {
+      const schema_ = schema__;
+      return {
+        enum: Object.values(schema_._def.values)
+      };
+    }
+    case ZodFirstPartyTypeKind2.ZodArray: {
+      const schema_ = schema__;
+      const def = schema_._def;
+      const json = { type: "array" };
+      json.items = zodToJsonSchema(def.type, childOptions);
+      if (def.exactLength) {
+        json.maxItems = def.exactLength.value;
+        json.minItems = def.exactLength.value;
+      }
+      if (def.minLength) {
+        json.minItems = def.minLength.value;
+      }
+      if (def.maxLength) {
+        json.maxItems = def.maxLength.value;
+      }
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodTuple: {
+      const schema_ = schema__;
+      const prefixItems = [];
+      const json = { type: "array" };
+      for (const item of schema_._def.items) {
+        prefixItems.push(zodToJsonSchema(item, childOptions));
+      }
+      if (prefixItems?.length) {
+        json.prefixItems = prefixItems;
+      }
+      if (schema_._def.rest) {
+        const items = zodToJsonSchema(schema_._def.rest, childOptions);
+        if (items) {
+          json.items = items;
+        }
+      }
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodObject: {
+      const schema_ = schema__;
+      const json = { type: "object" };
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(schema_.shape)) {
+        const { schema: schema2, matches } = extractJSONSchema(
+          zodToJsonSchema(value, childOptions),
+          (schema3) => schema3 === UNDEFINED_JSON_SCHEMA
+        );
+        if (schema2) {
+          properties[key] = schema2;
+        }
+        if (matches.length === 0) {
+          required.push(key);
+        }
+      }
+      if (Object.keys(properties).length) {
+        json.properties = properties;
+      }
+      if (required.length) {
+        json.required = required;
+      }
+      const additionalProperties = zodToJsonSchema(
+        schema_._def.catchall,
+        childOptions
+      );
+      if (schema_._def.unknownKeys === "strict") {
+        json.additionalProperties = additionalProperties === UNSUPPORTED_JSON_SCHEMA ? false : additionalProperties;
+      } else {
+        if (additionalProperties && additionalProperties !== UNSUPPORTED_JSON_SCHEMA) {
+          json.additionalProperties = additionalProperties;
+        }
+      }
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodRecord: {
+      const schema_ = schema__;
+      const json = { type: "object" };
+      json.additionalProperties = zodToJsonSchema(
+        schema_._def.valueType,
+        childOptions
+      );
+      return json;
+    }
+    case ZodFirstPartyTypeKind2.ZodSet: {
+      const schema_ = schema__;
+      return {
+        type: "array",
+        items: zodToJsonSchema(schema_._def.valueType, childOptions)
+      };
+    }
+    case ZodFirstPartyTypeKind2.ZodMap: {
+      const schema_ = schema__;
+      return {
+        type: "array",
+        items: {
+          type: "array",
+          prefixItems: [
+            zodToJsonSchema(schema_._def.keyType, childOptions),
+            zodToJsonSchema(schema_._def.valueType, childOptions)
+          ],
+          maxItems: 2,
+          minItems: 2
+        }
+      };
+    }
+    case ZodFirstPartyTypeKind2.ZodUnion:
+    case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion: {
+      const schema_ = schema__;
+      const anyOf = [];
+      for (const s of schema_._def.options) {
+        anyOf.push(zodToJsonSchema(s, childOptions));
+      }
+      return { anyOf };
+    }
+    case ZodFirstPartyTypeKind2.ZodIntersection: {
+      const schema_ = schema__;
+      const allOf = [];
+      for (const s of [schema_._def.left, schema_._def.right]) {
+        allOf.push(zodToJsonSchema(s, childOptions));
+      }
+      return { allOf };
+    }
+    case ZodFirstPartyTypeKind2.ZodLazy: {
+      const schema_ = schema__;
+      const maxLazyDepth = childOptions?.maxLazyDepth ?? 5;
+      const lazyDepth = childOptions?.lazyDepth ?? 0;
+      if (lazyDepth > maxLazyDepth) {
+        return {};
+      }
+      return zodToJsonSchema(schema_._def.getter(), {
+        ...childOptions,
+        lazyDepth: lazyDepth + 1
+      });
+    }
+    case ZodFirstPartyTypeKind2.ZodUnknown:
+    case ZodFirstPartyTypeKind2.ZodAny:
+    case void 0: {
+      return {};
+    }
+    case ZodFirstPartyTypeKind2.ZodOptional: {
+      const schema_ = schema__;
+      const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
+      return {
+        anyOf: [UNDEFINED_JSON_SCHEMA, inner]
+      };
+    }
+    case ZodFirstPartyTypeKind2.ZodReadonly: {
+      const schema_ = schema__;
+      return zodToJsonSchema(schema_._def.innerType, childOptions);
+    }
+    case ZodFirstPartyTypeKind2.ZodDefault: {
+      const schema_ = schema__;
+      return zodToJsonSchema(schema_._def.innerType, childOptions);
+    }
+    case ZodFirstPartyTypeKind2.ZodEffects: {
+      const schema_ = schema__;
+      if (schema_._def.effect.type === "transform" && childOptions?.mode === "output") {
+        return {};
+      }
+      return zodToJsonSchema(schema_._def.schema, childOptions);
+    }
+    case ZodFirstPartyTypeKind2.ZodCatch: {
+      const schema_ = schema__;
+      return zodToJsonSchema(schema_._def.innerType, childOptions);
+    }
+    case ZodFirstPartyTypeKind2.ZodBranded: {
+      const schema_ = schema__;
+      return zodToJsonSchema(schema_._def.type, childOptions);
+    }
+    case ZodFirstPartyTypeKind2.ZodPipeline: {
+      const schema_ = schema__;
+      return zodToJsonSchema(
+        childOptions?.mode === "output" ? schema_._def.out : schema_._def.in,
+        childOptions
+      );
+    }
+    case ZodFirstPartyTypeKind2.ZodNullable: {
+      const schema_ = schema__;
+      const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
+      return {
+        anyOf: [{ type: "null" }, inner]
+      };
+    }
+  }
+  const _expected = typeName;
+  return UNSUPPORTED_JSON_SCHEMA;
+}
+function extractJSONSchema(schema, check, matches = []) {
+  if (check(schema)) {
+    matches.push(schema);
+    return { schema: void 0, matches };
+  }
+  if (typeof schema === "boolean") {
+    return { schema, matches };
+  }
+  if (schema.anyOf && Object.keys(schema).every(
+    (k) => k === "anyOf" || NON_LOGIC_KEYWORDS.includes(k)
+  )) {
+    const anyOf = schema.anyOf.map((s) => extractJSONSchema(s, check, matches).schema).filter((v) => !!v);
+    if (anyOf.length === 1 && typeof anyOf[0] === "object") {
+      return { schema: { ...schema, anyOf: void 0, ...anyOf[0] }, matches };
+    }
+    return {
+      schema: {
+        ...schema,
+        anyOf
+      },
+      matches
+    };
+  }
+  if (schema.oneOf && Object.keys(schema).every(
+    (k) => k === "oneOf" || NON_LOGIC_KEYWORDS.includes(k)
+  )) {
+    const oneOf = schema.oneOf.map((s) => extractJSONSchema(s, check, matches).schema).filter((v) => !!v);
+    if (oneOf.length === 1 && typeof oneOf[0] === "object") {
+      return { schema: { ...schema, oneOf: void 0, ...oneOf[0] }, matches };
+    }
+    return {
+      schema: {
+        ...schema,
+        oneOf
+      },
+      matches
+    };
+  }
+  return { schema, matches };
+}
+var ZodToJsonSchemaConverter = class {
+  condition(schema) {
+    return Boolean(schema && schema["~standard"].vendor === "zod");
+  }
+  convert(schema, options) {
+    const jsonSchema = schema;
+    return zodToJsonSchema(jsonSchema, { mode: options.strategy });
+  }
+};
 export {
+  NON_LOGIC_KEYWORDS,
+  UNDEFINED_JSON_SCHEMA,
+  UNSUPPORTED_JSON_SCHEMA,
+  ZodSmartCoercionPlugin as ZodAutoCoercePlugin,
+  ZodSmartCoercionPlugin,
+  ZodToJsonSchemaConverter,
   blob,
   file,
   getCustomJSONSchema,
@@ -143,6 +974,7 @@ export {
   openapi,
   oz,
   regexp,
-  url
+  url,
+  zodToJsonSchema
 };
 //# sourceMappingURL=index.js.map

package/dist/src/coercer.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@orpc/server';
+import type { Plugin } from '@orpc/server/plugins';
+import type { StandardHandlerOptions } from '@orpc/server/standard';
+export declare class ZodSmartCoercionPlugin<TContext extends Context> implements Plugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+export { 
+/**
+ * @deprecated ZodAutoCoercePlugin has renamed to ZodSmartCoercionPlugin
+ */
+ZodSmartCoercionPlugin as ZodAutoCoercePlugin, };
+//# sourceMappingURL=coercer.d.ts.map

package/dist/src/converter.d.ts

@@ -0,0 +1,50 @@
+import type { Schema } from '@orpc/contract';
+import type { JSONSchema, SchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export declare const NON_LOGIC_KEYWORDS: ("$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "contentEncoding" | "contentMediaType" | "default" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly")[];
+export declare const UNSUPPORTED_JSON_SCHEMA: {
+    not: {};
+};
+export declare const UNDEFINED_JSON_SCHEMA: {
+    const: string;
+};
+export interface ZodToJsonSchemaOptions {
+    /**
+     * Max depth of lazy type, if it exceeds.
+     *
+     * Used `{}` when reach max depth
+     *
+     * @default 5
+     */
+    maxLazyDepth?: number;
+    /**
+     * The length used to track the depth of lazy type
+     *
+     * @internal
+     */
+    lazyDepth?: number;
+    /**
+     * The expected json schema for input or output zod schema
+     *
+     * @default input
+     */
+    mode?: 'input' | 'output';
+    /**
+     * Track if current level schema is handled custom json schema to prevent recursive
+     *
+     * @internal
+     */
+    isHandledCustomJSONSchema?: boolean;
+    /**
+     * Track if current level schema is handled zod description to prevent recursive
+     *
+     * @internal
+     */
+    isHandledZodDescription?: boolean;
+}
+export declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema.JSONSchema, boolean>;
+export declare class ZodToJsonSchemaConverter implements SchemaConverter {
+    condition(schema: Schema): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+//# sourceMappingURL=converter.d.ts.map

package/dist/src/index.d.ts

@@ -1,31 +1,4 @@
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-import { type CustomErrorParams, type input, type output, type ZodEffects, type ZodType, type ZodTypeAny, type ZodTypeDef } from 'zod';
-export type CustomZodType = 'File' | 'Blob' | 'Invalid Date' | 'RegExp' | 'URL';
-type CustomParams = CustomErrorParams & {
-    fatal?: boolean;
-};
-export declare function getCustomZodType(def: ZodTypeDef): CustomZodType | undefined;
-export declare function getCustomZodFileMimeType(def: ZodTypeDef): string | undefined;
-export declare function getCustomJSONSchema(def: ZodTypeDef, options?: {
-    mode?: 'input' | 'output';
-}): Exclude<JSONSchema, boolean> | undefined;
-export declare function file(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<InstanceType<typeof File>, ZodTypeDef, InstanceType<typeof File>> & {
-    type: (mimeType: string, params?: string | CustomParams | ((input: unknown) => CustomParams)) => ZodEffects<ZodType<InstanceType<typeof File>, ZodTypeDef, InstanceType<typeof File>>, InstanceType<typeof File>, InstanceType<typeof File>>;
-};
-export declare function blob(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<InstanceType<typeof Blob>, ZodTypeDef, InstanceType<typeof Blob>>;
-export declare function invalidDate(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<Date, ZodTypeDef, Date>;
-export declare function regexp(options?: CustomParams): ZodType<RegExp, ZodTypeDef, RegExp>;
-export declare function url(options?: CustomParams): ZodType<URL, ZodTypeDef, URL>;
-export declare function openapi<T extends ZodTypeAny, TMode extends 'input' | 'output' | 'both' = 'both'>(schema: T, custom: Exclude<JSONSchema<TMode extends 'input' ? input<T> : TMode extends 'output' ? output<T> : input<T> & output<T>>, boolean>, options?: {
-    mode: TMode;
-}): ReturnType<T['refine']>;
-export declare const oz: {
-    openapi: typeof openapi;
-    file: typeof file;
-    blob: typeof blob;
-    invalidDate: typeof invalidDate;
-    regexp: typeof regexp;
-    url: typeof url;
-};
-export {};
+export * from './coercer';
+export * from './converter';
+export * from './schemas';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/schemas.d.ts

@@ -0,0 +1,31 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+import { type CustomErrorParams, type input, type output, type ZodEffects, type ZodType, type ZodTypeAny, type ZodTypeDef } from 'zod';
+export type CustomZodType = 'File' | 'Blob' | 'Invalid Date' | 'RegExp' | 'URL';
+type CustomParams = CustomErrorParams & {
+    fatal?: boolean;
+};
+export declare function getCustomZodType(def: ZodTypeDef): CustomZodType | undefined;
+export declare function getCustomZodFileMimeType(def: ZodTypeDef): string | undefined;
+export declare function getCustomJSONSchema(def: ZodTypeDef, options?: {
+    mode?: 'input' | 'output';
+}): Exclude<JSONSchema, boolean> | undefined;
+export declare function file(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<InstanceType<typeof File>, ZodTypeDef, InstanceType<typeof File>> & {
+    type(mimeType: string, params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodEffects<ZodType<InstanceType<typeof File>, ZodTypeDef, InstanceType<typeof File>>, InstanceType<typeof File>, InstanceType<typeof File>>;
+};
+export declare function blob(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<InstanceType<typeof Blob>, ZodTypeDef, InstanceType<typeof Blob>>;
+export declare function invalidDate(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<Date, ZodTypeDef, Date>;
+export declare function regexp(options?: CustomParams): ZodType<RegExp, ZodTypeDef, RegExp>;
+export declare function url(options?: CustomParams): ZodType<URL, ZodTypeDef, URL>;
+export declare function openapi<T extends ZodTypeAny, TMode extends 'input' | 'output' | 'both' = 'both'>(schema: T, custom: Exclude<JSONSchema<TMode extends 'input' ? input<T> : TMode extends 'output' ? output<T> : input<T> & output<T>>, boolean>, options?: {
+    mode: TMode;
+}): ReturnType<T['refine']>;
+export declare const oz: {
+    openapi: typeof openapi;
+    file: typeof file;
+    blob: typeof blob;
+    invalidDate: typeof invalidDate;
+    regexp: typeof regexp;
+    url: typeof url;
+};
+export {};
+//# sourceMappingURL=schemas.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/zod",
   "type": "module",
-  "version": "0.0.0-next.ee0aeaf",
+  "version": "0.0.0-next.f17a1a0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -28,10 +28,17 @@
     "!**/*.tsbuildinfo",
     "dist"
   ],
+  "peerDependencies": {
+    "@orpc/contract": "0.0.0-next.f17a1a0",
+    "@orpc/openapi": "0.0.0-next.f17a1a0",
+    "@orpc/server": "0.0.0-next.f17a1a0"
+  },
   "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
     "json-schema-typed": "^8.0.1",
     "wildcard-match": "^5.1.3",
-    "zod": "^3.24.1"
+    "zod": "^3.24.1",
+    "@orpc/shared": "0.0.0-next.f17a1a0"
   },
   "scripts": {
     "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",