@orpc/zod 0.0.0-next.af8ac85 → 0.0.0-next.b0f324e

package/README.md

@@ -0,0 +1,132 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</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.d.mts

@@ -0,0 +1,89 @@
+import { Context } from '@orpc/server';
+import { Plugin } from '@orpc/server/plugins';
+import { StandardHandlerOptions } from '@orpc/server/standard';
+import { Schema } from '@orpc/contract';
+import { JSONSchema, SchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { JSONSchema as JSONSchema$1 } from 'json-schema-typed/draft-2020-12';
+import { ZodTypeDef, CustomErrorParams, ZodType, ZodEffects, ZodTypeAny, input, output } from 'zod';
+
+declare class ZodSmartCoercionPlugin<TContext extends Context> implements Plugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+declare const NON_LOGIC_KEYWORDS: ("default" | "$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly" | "contentEncoding" | "contentMediaType")[];
+declare const UNSUPPORTED_JSON_SCHEMA: {
+    not: {};
+};
+declare const UNDEFINED_JSON_SCHEMA: {
+    const: string;
+};
+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;
+}
+declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema.JSONSchema, boolean>;
+declare class ZodToJsonSchemaConverter implements SchemaConverter {
+    condition(schema: Schema): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+
+type CustomZodType = 'File' | 'Blob' | 'Invalid Date' | 'RegExp' | 'URL';
+type CustomParams = CustomErrorParams & {
+    fatal?: boolean;
+};
+declare function getCustomZodType(def: ZodTypeDef): CustomZodType | undefined;
+declare function getCustomZodFileMimeType(def: ZodTypeDef): string | undefined;
+declare function getCustomJSONSchema(def: ZodTypeDef, options?: {
+    mode?: 'input' | 'output';
+}): Exclude<JSONSchema$1, boolean> | undefined;
+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>>;
+};
+declare function blob(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<InstanceType<typeof Blob>, ZodTypeDef, InstanceType<typeof Blob>>;
+declare function invalidDate(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<Date, ZodTypeDef, Date>;
+declare function regexp(options?: CustomParams): ZodType<RegExp, ZodTypeDef, RegExp>;
+declare function url(options?: CustomParams): ZodType<URL, ZodTypeDef, URL>;
+declare function openapi<T extends ZodTypeAny, TMode extends 'input' | 'output' | 'both' = 'both'>(schema: T, custom: Exclude<JSONSchema$1<TMode extends 'input' ? input<T> : TMode extends 'output' ? output<T> : input<T> & output<T>>, boolean>, options?: {
+    mode: TMode;
+}): ReturnType<T['refine']>;
+declare const oz: {
+    openapi: typeof openapi;
+    file: typeof file;
+    blob: typeof blob;
+    invalidDate: typeof invalidDate;
+    regexp: typeof regexp;
+    url: typeof url;
+};
+
+export { type CustomZodType, NON_LOGIC_KEYWORDS, UNDEFINED_JSON_SCHEMA, UNSUPPORTED_JSON_SCHEMA, ZodSmartCoercionPlugin as ZodAutoCoercePlugin, ZodSmartCoercionPlugin, ZodToJsonSchemaConverter, type ZodToJsonSchemaOptions, blob, file, getCustomJSONSchema, getCustomZodFileMimeType, getCustomZodType, invalidDate, openapi, oz, regexp, url, zodToJsonSchema };

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import { Context } from '@orpc/server';
+import { Plugin } from '@orpc/server/plugins';
+import { StandardHandlerOptions } from '@orpc/server/standard';
+import { Schema } from '@orpc/contract';
+import { JSONSchema, SchemaConverter, SchemaConvertOptions } from '@orpc/openapi';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { JSONSchema as JSONSchema$1 } from 'json-schema-typed/draft-2020-12';
+import { ZodTypeDef, CustomErrorParams, ZodType, ZodEffects, ZodTypeAny, input, output } from 'zod';
+
+declare class ZodSmartCoercionPlugin<TContext extends Context> implements Plugin<TContext> {
+    init(options: StandardHandlerOptions<TContext>): void;
+}
+
+declare const NON_LOGIC_KEYWORDS: ("default" | "$anchor" | "$comment" | "$defs" | "$dynamicAnchor" | "$dynamicRef" | "$id" | "$schema" | "$vocabulary" | "definitions" | "deprecated" | "description" | "examples" | "format" | "readOnly" | "title" | "writeOnly" | "contentEncoding" | "contentMediaType")[];
+declare const UNSUPPORTED_JSON_SCHEMA: {
+    not: {};
+};
+declare const UNDEFINED_JSON_SCHEMA: {
+    const: string;
+};
+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;
+}
+declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema.JSONSchema, boolean>;
+declare class ZodToJsonSchemaConverter implements SchemaConverter {
+    condition(schema: Schema): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+
+type CustomZodType = 'File' | 'Blob' | 'Invalid Date' | 'RegExp' | 'URL';
+type CustomParams = CustomErrorParams & {
+    fatal?: boolean;
+};
+declare function getCustomZodType(def: ZodTypeDef): CustomZodType | undefined;
+declare function getCustomZodFileMimeType(def: ZodTypeDef): string | undefined;
+declare function getCustomJSONSchema(def: ZodTypeDef, options?: {
+    mode?: 'input' | 'output';
+}): Exclude<JSONSchema$1, boolean> | undefined;
+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>>;
+};
+declare function blob(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<InstanceType<typeof Blob>, ZodTypeDef, InstanceType<typeof Blob>>;
+declare function invalidDate(params?: string | CustomParams | ((input: unknown) => CustomParams)): ZodType<Date, ZodTypeDef, Date>;
+declare function regexp(options?: CustomParams): ZodType<RegExp, ZodTypeDef, RegExp>;
+declare function url(options?: CustomParams): ZodType<URL, ZodTypeDef, URL>;
+declare function openapi<T extends ZodTypeAny, TMode extends 'input' | 'output' | 'both' = 'both'>(schema: T, custom: Exclude<JSONSchema$1<TMode extends 'input' ? input<T> : TMode extends 'output' ? output<T> : input<T> & output<T>>, boolean>, options?: {
+    mode: TMode;
+}): ReturnType<T['refine']>;
+declare const oz: {
+    openapi: typeof openapi;
+    file: typeof file;
+    blob: typeof blob;
+    invalidDate: typeof invalidDate;
+    regexp: typeof regexp;
+    url: typeof url;
+};
+
+export { type CustomZodType, NON_LOGIC_KEYWORDS, UNDEFINED_JSON_SCHEMA, UNSUPPORTED_JSON_SCHEMA, ZodSmartCoercionPlugin as ZodAutoCoercePlugin, ZodSmartCoercionPlugin, ZodToJsonSchemaConverter, type ZodToJsonSchemaOptions, blob, file, getCustomJSONSchema, getCustomZodFileMimeType, getCustomZodType, invalidDate, openapi, oz, regexp, url, zodToJsonSchema };

package/dist/{index.js → index.mjs}

@@ -1,46 +1,23 @@
-// ../../node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/getType.js
-function getType(payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
-}
-
-// ../../node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/isPlainObject.js
-function isPlainObject(payload) {
-  if (getType(payload) !== "Object")
-    return false;
-  const prototype = Object.getPrototypeOf(payload);
-  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
-}
+import { guard, isObject } from '@orpc/shared';
+import { getCustomZodType as getCustomZodType$1 } from '@orpc/zod';
+import { ZodFirstPartyTypeKind, custom } from 'zod';
+import { JSONSchemaFormat } from '@orpc/openapi';
+import escapeStringRegexp from 'escape-string-regexp';
+import wcmatch from 'wildcard-match';
 
-// ../../node_modules/.pnpm/radash@12.1.0/node_modules/radash/dist/esm/async.mjs
-var guard = (func, shouldGuard) => {
-  const _guard = (err) => {
-    if (shouldGuard && !shouldGuard(err))
-      throw err;
-    return void 0;
-  };
-  const isPromise2 = (result) => result instanceof Promise;
-  try {
-    const result = func();
-    return isPromise2(result) ? result.catch(_guard) : result;
-  } catch (err) {
-    return _guard(err);
+class ZodSmartCoercionPlugin {
+  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 });
+    });
   }
-};
-
-// src/coercer.ts
-import {
-  ZodFirstPartyTypeKind
-} from "zod";
-var ZodCoercer = class {
-  coerce(schema, value) {
-    if (!schema || schema["~standard"].vendor !== "zod") {
-      return value;
-    }
-    const zodSchema = schema;
-    const coerced = zodCoerceInternal(zodSchema, value, { bracketNotation: true });
-    return coerced;
-  }
-};
+}
 function zodCoerceInternal(schema, value, options) {
   const isRoot = options?.isRoot ?? true;
   const options_ = { ...options, isRoot: false };
@@ -51,7 +28,7 @@ function zodCoerceInternal(schema, value, options) {
     }
     return zodCoerceInternal(schema, value, options_);
   }
-  const customType = getCustomZodType(schema._def);
+  const customType = getCustomZodType$1(schema._def);
   if (customType === "Invalid Date") {
     if (typeof value === "string" && value.toLocaleLowerCase() === "invalid date") {
       return /* @__PURE__ */ new Date("Invalid Date");
@@ -66,9 +43,9 @@ function zodCoerceInternal(schema, value, options) {
     }
   } else if (customType === "URL") {
     if (typeof value === "string") {
-      const url2 = guard(() => new URL(value));
-      if (url2 !== void 0) {
-        return url2;
+      const url = guard(() => new URL(value));
+      if (url !== void 0) {
+        return url;
       }
     }
   }
@@ -125,7 +102,7 @@ function zodCoerceInternal(schema, value, options) {
       if (value === void 0) {
         return [];
       }
-      if (isPlainObject(value) && Object.keys(value).every((k) => /^[1-9]\d*$/.test(k) || k === "0")) {
+      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) {
@@ -136,7 +113,7 @@ function zodCoerceInternal(schema, value, options) {
     }
   } else if (typeName === ZodFirstPartyTypeKind.ZodObject) {
     const schema_ = schema;
-    if (isPlainObject(value)) {
+    if (isObject(value)) {
       const newObj = {};
       const keys = /* @__PURE__ */ new Set([
         ...Object.keys(value),
@@ -174,7 +151,7 @@ function zodCoerceInternal(schema, value, options) {
       if (value === void 0) {
         return /* @__PURE__ */ new Set();
       }
-      if (isPlainObject(value) && Object.keys(value).every((k) => /^[1-9]\d*$/.test(k) || k === "0")) {
+      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) {
@@ -197,9 +174,9 @@ function zodCoerceInternal(schema, value, options) {
       if (value === void 0) {
         return /* @__PURE__ */ new Map();
       }
-      if (isPlainObject(value)) {
+      if (isObject(value)) {
         const arr = Array.from({ length: Object.keys(value).length }).fill(void 0).map(
-          (_, i) => isPlainObject(value[i]) && Object.keys(value[i]).length === 2 && "0" in value[i] && "1" in value[i] ? [value[i]["0"], value[i]["1"]] : void 0
+          (_, 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(
@@ -213,7 +190,7 @@ function zodCoerceInternal(schema, value, options) {
     }
   } else if (typeName === ZodFirstPartyTypeKind.ZodRecord) {
     const schema_ = schema;
-    if (isPlainObject(value)) {
+    if (isObject(value)) {
       const newObj = {};
       for (const [k, v] of Object.entries(value)) {
         const key = zodCoerceInternal(schema_._def.keyType, k, options_);
@@ -334,38 +311,15 @@ function zodCoerceInternal(schema, value, options) {
         }
       }
     }
-  } else {
-    const _expected = typeName;
-  }
+  } else ;
   return value;
 }
 
-// src/converter.ts
-import { JSONSchemaFormat } from "@orpc/openapi";
-
-// ../../node_modules/.pnpm/escape-string-regexp@5.0.0/node_modules/escape-string-regexp/index.js
-function escapeStringRegexp(string) {
-  if (typeof string !== "string") {
-    throw new TypeError("Expected a string");
-  }
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
-}
-
-// src/converter.ts
-import {
-  ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2
-} from "zod";
-
-// src/schemas.ts
-import wcmatch from "wildcard-match";
-import {
-  custom
-} from "zod";
-var customZodTypeSymbol = Symbol("customZodTypeSymbol");
-var customZodFileMimeTypeSymbol = Symbol("customZodFileMimeTypeSymbol");
-var CUSTOM_JSON_SCHEMA_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA");
-var CUSTOM_JSON_SCHEMA_INPUT_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA_INPUT");
-var CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA_OUTPUT");
+const customZodTypeSymbol = Symbol("customZodTypeSymbol");
+const customZodFileMimeTypeSymbol = Symbol("customZodFileMimeTypeSymbol");
+const CUSTOM_JSON_SCHEMA_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA");
+const CUSTOM_JSON_SCHEMA_INPUT_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA_INPUT");
+const CUSTOM_JSON_SCHEMA_OUTPUT_SYMBOL = Symbol("CUSTOM_JSON_SCHEMA_OUTPUT");
 function getCustomZodType(def) {
   return customZodTypeSymbol in def ? def[customZodTypeSymbol] : void 0;
 }
@@ -483,7 +437,7 @@ function openapi(schema, custom2, options) {
   });
   return newSchema;
 }
-var oz = {
+const oz = {
   openapi,
   file,
   blob,
@@ -492,8 +446,7 @@ var oz = {
   url
 };
 
-// src/converter.ts
-var NON_LOGIC_KEYWORDS = [
+const NON_LOGIC_KEYWORDS = [
   // Core Documentation Keywords
   "$anchor",
   "$comment",
@@ -520,14 +473,24 @@ var NON_LOGIC_KEYWORDS = [
   "$dynamicAnchor",
   "$dynamicRef"
 ];
-var UNSUPPORTED_JSON_SCHEMA = { not: {} };
-var UNDEFINED_JSON_SCHEMA = { const: "undefined" };
+const UNSUPPORTED_JSON_SCHEMA = { not: {} };
+const 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) {
@@ -541,7 +504,7 @@ function zodToJsonSchema(schema, options) {
       };
     }
   }
-  const childOptions = { ...options, isHandledCustomJSONSchema: false };
+  const childOptions = { ...options, isHandledCustomJSONSchema: false, isHandledZodDescription: false };
   const customType = getCustomZodType(schema__._def);
   switch (customType) {
     case "Blob": {
@@ -564,10 +527,9 @@ function zodToJsonSchema(schema, options) {
       return { type: "string", format: JSONSchemaFormat.URI };
     }
   }
-  const _expectedCustomType = customType;
   const typeName = schema__._def.typeName;
   switch (typeName) {
-    case ZodFirstPartyTypeKind2.ZodString: {
+    case ZodFirstPartyTypeKind.ZodString: {
       const schema_ = schema__;
       const json = { type: "string" };
       for (const check of schema_._def.checks) {
@@ -643,13 +605,13 @@ function zodToJsonSchema(schema, options) {
             json.pattern = "^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$";
             break;
           default: {
-            const _expect = check.kind;
+            check.kind;
           }
         }
       }
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodNumber: {
+    case ZodFirstPartyTypeKind.ZodNumber: {
       const schema_ = schema__;
       const json = { type: "number" };
       for (const check of schema_._def.checks) {
@@ -667,53 +629,54 @@ function zodToJsonSchema(schema, options) {
             json.multipleOf = check.value;
             break;
           default: {
-            const _expect = check.kind;
+            check.kind;
           }
         }
       }
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodNaN: {
+    case ZodFirstPartyTypeKind.ZodNaN: {
       return { const: "NaN" };
     }
-    case ZodFirstPartyTypeKind2.ZodBigInt: {
+    case ZodFirstPartyTypeKind.ZodBigInt: {
       const json = { type: "string", pattern: "^-?[0-9]+$" };
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodBoolean: {
+    case ZodFirstPartyTypeKind.ZodBoolean: {
       return { type: "boolean" };
     }
-    case ZodFirstPartyTypeKind2.ZodDate: {
+    case ZodFirstPartyTypeKind.ZodDate: {
       const schema2 = { type: "string", format: JSONSchemaFormat.Date };
       return schema2;
     }
-    case ZodFirstPartyTypeKind2.ZodNull: {
+    case ZodFirstPartyTypeKind.ZodNull: {
       return { type: "null" };
     }
-    case ZodFirstPartyTypeKind2.ZodVoid:
-    case ZodFirstPartyTypeKind2.ZodUndefined: {
+    case ZodFirstPartyTypeKind.ZodVoid:
+    case ZodFirstPartyTypeKind.ZodUndefined: {
       return UNDEFINED_JSON_SCHEMA;
     }
-    case ZodFirstPartyTypeKind2.ZodLiteral: {
+    case ZodFirstPartyTypeKind.ZodLiteral: {
       const schema_ = schema__;
       return { const: schema_._def.value };
     }
-    case ZodFirstPartyTypeKind2.ZodEnum: {
+    case ZodFirstPartyTypeKind.ZodEnum: {
       const schema_ = schema__;
       return {
         enum: schema_._def.values
       };
     }
-    case ZodFirstPartyTypeKind2.ZodNativeEnum: {
+    case ZodFirstPartyTypeKind.ZodNativeEnum: {
       const schema_ = schema__;
       return {
         enum: Object.values(schema_._def.values)
       };
     }
-    case ZodFirstPartyTypeKind2.ZodArray: {
+    case ZodFirstPartyTypeKind.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;
@@ -726,7 +689,7 @@ function zodToJsonSchema(schema, options) {
       }
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodTuple: {
+    case ZodFirstPartyTypeKind.ZodTuple: {
       const schema_ = schema__;
       const prefixItems = [];
       const json = { type: "array" };
@@ -744,7 +707,7 @@ function zodToJsonSchema(schema, options) {
       }
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodObject: {
+    case ZodFirstPartyTypeKind.ZodObject: {
       const schema_ = schema__;
       const json = { type: "object" };
       const properties = {};
@@ -780,7 +743,7 @@ function zodToJsonSchema(schema, options) {
       }
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodRecord: {
+    case ZodFirstPartyTypeKind.ZodRecord: {
       const schema_ = schema__;
       const json = { type: "object" };
       json.additionalProperties = zodToJsonSchema(
@@ -789,14 +752,14 @@ function zodToJsonSchema(schema, options) {
       );
       return json;
     }
-    case ZodFirstPartyTypeKind2.ZodSet: {
+    case ZodFirstPartyTypeKind.ZodSet: {
       const schema_ = schema__;
       return {
         type: "array",
         items: zodToJsonSchema(schema_._def.valueType, childOptions)
       };
     }
-    case ZodFirstPartyTypeKind2.ZodMap: {
+    case ZodFirstPartyTypeKind.ZodMap: {
       const schema_ = schema__;
       return {
         type: "array",
@@ -811,8 +774,8 @@ function zodToJsonSchema(schema, options) {
         }
       };
     }
-    case ZodFirstPartyTypeKind2.ZodUnion:
-    case ZodFirstPartyTypeKind2.ZodDiscriminatedUnion: {
+    case ZodFirstPartyTypeKind.ZodUnion:
+    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
       const schema_ = schema__;
       const anyOf = [];
       for (const s of schema_._def.options) {
@@ -820,7 +783,7 @@ function zodToJsonSchema(schema, options) {
       }
       return { anyOf };
     }
-    case ZodFirstPartyTypeKind2.ZodIntersection: {
+    case ZodFirstPartyTypeKind.ZodIntersection: {
       const schema_ = schema__;
       const allOf = [];
       for (const s of [schema_._def.left, schema_._def.right]) {
@@ -828,7 +791,7 @@ function zodToJsonSchema(schema, options) {
       }
       return { allOf };
     }
-    case ZodFirstPartyTypeKind2.ZodLazy: {
+    case ZodFirstPartyTypeKind.ZodLazy: {
       const schema_ = schema__;
       const maxLazyDepth = childOptions?.maxLazyDepth ?? 5;
       const lazyDepth = childOptions?.lazyDepth ?? 0;
@@ -840,49 +803,49 @@ function zodToJsonSchema(schema, options) {
         lazyDepth: lazyDepth + 1
       });
     }
-    case ZodFirstPartyTypeKind2.ZodUnknown:
-    case ZodFirstPartyTypeKind2.ZodAny:
+    case ZodFirstPartyTypeKind.ZodUnknown:
+    case ZodFirstPartyTypeKind.ZodAny:
     case void 0: {
       return {};
     }
-    case ZodFirstPartyTypeKind2.ZodOptional: {
+    case ZodFirstPartyTypeKind.ZodOptional: {
       const schema_ = schema__;
       const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
       return {
         anyOf: [UNDEFINED_JSON_SCHEMA, inner]
       };
     }
-    case ZodFirstPartyTypeKind2.ZodReadonly: {
+    case ZodFirstPartyTypeKind.ZodReadonly: {
       const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
-    case ZodFirstPartyTypeKind2.ZodDefault: {
+    case ZodFirstPartyTypeKind.ZodDefault: {
       const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
-    case ZodFirstPartyTypeKind2.ZodEffects: {
+    case ZodFirstPartyTypeKind.ZodEffects: {
       const schema_ = schema__;
       if (schema_._def.effect.type === "transform" && childOptions?.mode === "output") {
         return {};
       }
       return zodToJsonSchema(schema_._def.schema, childOptions);
     }
-    case ZodFirstPartyTypeKind2.ZodCatch: {
+    case ZodFirstPartyTypeKind.ZodCatch: {
       const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
-    case ZodFirstPartyTypeKind2.ZodBranded: {
+    case ZodFirstPartyTypeKind.ZodBranded: {
       const schema_ = schema__;
       return zodToJsonSchema(schema_._def.type, childOptions);
     }
-    case ZodFirstPartyTypeKind2.ZodPipeline: {
+    case ZodFirstPartyTypeKind.ZodPipeline: {
       const schema_ = schema__;
       return zodToJsonSchema(
         childOptions?.mode === "output" ? schema_._def.out : schema_._def.in,
         childOptions
       );
     }
-    case ZodFirstPartyTypeKind2.ZodNullable: {
+    case ZodFirstPartyTypeKind.ZodNullable: {
       const schema_ = schema__;
       const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
       return {
@@ -890,7 +853,6 @@ function zodToJsonSchema(schema, options) {
       };
     }
   }
-  const _expected = typeName;
   return UNSUPPORTED_JSON_SCHEMA;
 }
 function extractJSONSchema(schema, check, matches = []) {
@@ -933,7 +895,7 @@ function extractJSONSchema(schema, check, matches = []) {
   }
   return { schema, matches };
 }
-var ZodToJsonSchemaConverter = class {
+class ZodToJsonSchemaConverter {
   condition(schema) {
     return Boolean(schema && schema["~standard"].vendor === "zod");
   }
@@ -941,23 +903,6 @@ var ZodToJsonSchemaConverter = class {
     const jsonSchema = schema;
     return zodToJsonSchema(jsonSchema, { mode: options.strategy });
   }
-};
-export {
-  NON_LOGIC_KEYWORDS,
-  UNDEFINED_JSON_SCHEMA,
-  UNSUPPORTED_JSON_SCHEMA,
-  ZodCoercer,
-  ZodToJsonSchemaConverter,
-  blob,
-  file,
-  getCustomJSONSchema,
-  getCustomZodFileMimeType,
-  getCustomZodType,
-  invalidDate,
-  openapi,
-  oz,
-  regexp,
-  url,
-  zodToJsonSchema
-};
-//# sourceMappingURL=index.js.map
+}
+
+export { NON_LOGIC_KEYWORDS, UNDEFINED_JSON_SCHEMA, UNSUPPORTED_JSON_SCHEMA, ZodSmartCoercionPlugin as ZodAutoCoercePlugin, ZodSmartCoercionPlugin, ZodToJsonSchemaConverter, blob, file, getCustomJSONSchema, getCustomZodFileMimeType, getCustomZodType, invalidDate, openapi, oz, regexp, url, zodToJsonSchema };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/zod",
   "type": "module",
-  "version": "0.0.0-next.af8ac85",
+  "version": "0.0.0-next.b0f324e",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,29 +15,29 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "peerDependencies": {
-    "@orpc/openapi": "0.0.0-next.af8ac85"
+    "@orpc/contract": "0.0.0-next.b0f324e",
+    "@orpc/openapi": "0.0.0-next.b0f324e",
+    "@orpc/server": "0.0.0-next.b0f324e"
   },
   "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "escape-string-regexp": "^5.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.b0f324e"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/coercer.d.ts

@@ -1,6 +0,0 @@
-import type { Schema } from '@orpc/contract';
-import type { SchemaCoercer } from '@orpc/openapi/fetch';
-export declare class ZodCoercer implements SchemaCoercer {
-    coerce(schema: Schema, value: unknown): unknown;
-}
-//# sourceMappingURL=coercer.d.ts.map

package/dist/src/converter.d.ts

@@ -1,44 +0,0 @@
-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;
-}
-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,4 +0,0 @@
-export * from './coercer';
-export * from './converter';
-export * from './schemas';
-//# sourceMappingURL=index.d.ts.map

package/dist/src/schemas.d.ts

@@ -1,31 +0,0 @@
-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