@orpc/openapi 0.15.0 → 0.17.0

package/dist/{chunk-KZIT2WCV.js → chunk-CMRY2Z4J.js}

@@ -1,12 +1,13 @@
 // src/utils.ts
 import { isContractProcedure } from "@orpc/contract";
-import { isLazy, isProcedure, ROUTER_CONTRACT_SYMBOL } from "@orpc/server";
+import { flatLazy, getRouterContract, isLazy, isProcedure } from "@orpc/server";
 function eachContractProcedureLeaf(options, callback, result = [], isCurrentRouterContract = false) {
-  if (!isCurrentRouterContract && ROUTER_CONTRACT_SYMBOL in options.router && options.router[ROUTER_CONTRACT_SYMBOL]) {
+  const hiddenContract = getRouterContract(options.router);
+  if (!isCurrentRouterContract && hiddenContract) {
     return eachContractProcedureLeaf(
       {
         path: options.path,
-        router: options.router[ROUTER_CONTRACT_SYMBOL]
+        router: hiddenContract
       },
       callback,
       result,
@@ -15,12 +16,12 @@ function eachContractProcedureLeaf(options, callback, result = [], isCurrentRout
   }
   if (isLazy(options.router)) {
     result.push({
-      lazy: options.router,
+      lazy: flatLazy(options.router),
       path: options.path
     });
   } else if (isProcedure(options.router)) {
     callback({
-      contract: options.router.zz$p.contract,
+      contract: options.router["~orpc"].contract,
       path: options.path
     });
   } else if (isContractProcedure(options.router)) {
@@ -42,8 +43,12 @@ function eachContractProcedureLeaf(options, callback, result = [], isCurrentRout
   }
   return result;
 }
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
 
 export {
-  eachContractProcedureLeaf
+  eachContractProcedureLeaf,
+  standardizeHTTPPath
 };
-//# sourceMappingURL=chunk-KZIT2WCV.js.map
+//# sourceMappingURL=chunk-CMRY2Z4J.js.map

package/dist/fetch.js

@@ -1,16 +1,16 @@
 import {
-  eachContractProcedureLeaf
-} from "./chunk-KZIT2WCV.js";
+  eachContractProcedureLeaf,
+  standardizeHTTPPath
+} from "./chunk-CMRY2Z4J.js";
 
 // src/fetch/base-handler.ts
-import { ORPC_HEADER, standardizeHTTPPath } from "@orpc/contract";
-import { createProcedureCaller, isLazy, isProcedure, LAZY_LOADER_SYMBOL, LAZY_ROUTER_PREFIX_SYMBOL, ORPCError } from "@orpc/server";
-import { executeWithHooks, isPlainObject, mapValues, trim, value } from "@orpc/shared";
+import { createProcedureClient, getLazyRouterPrefix, getRouterChild, isProcedure, LAZY_LOADER_SYMBOL, ORPCError, unlazy } from "@orpc/server";
+import { executeWithHooks, isPlainObject, mapValues, ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, trim, value } from "@orpc/shared";
 import { OpenAPIDeserializer, OpenAPISerializer, zodCoerce } from "@orpc/transformer";
 function createOpenAPIHandler(createHonoRouter) {
   const resolveRouter = createResolveRouter(createHonoRouter);
   return async (options) => {
-    if (options.request.headers.get(ORPC_HEADER) !== null) {
+    if (options.request.headers.get(ORPC_PROTOCOL_HEADER)?.includes(ORPC_PROTOCOL_VALUE)) {
       return void 0;
     }
     const context = await value(options.context);
@@ -25,22 +25,15 @@ function createOpenAPIHandler(createHonoRouter) {
       if (!match) {
         throw new ORPCError({ code: "NOT_FOUND", message: "Not found" });
       }
-      const procedure = isLazy(match.procedure) ? (await match.procedure[LAZY_LOADER_SYMBOL]()).default : match.procedure;
-      const path = match.path;
-      if (!isProcedure(procedure)) {
-        throw new ORPCError({
-          code: "NOT_FOUND",
-          message: "Not found"
-        });
-      }
-      const params = procedure.zz$p.contract.zz$cp.InputSchema ? zodCoerce(
-        procedure.zz$p.contract.zz$cp.InputSchema,
+      const { path, procedure } = match;
+      const params = procedure["~orpc"].contract["~orpc"].InputSchema ? zodCoerce(
+        procedure["~orpc"].contract["~orpc"].InputSchema,
         match.params,
         { bracketNotation: true }
       ) : match.params;
       const input = await deserializeInput(options.request, procedure);
       const mergedInput = mergeParamsAndInput(params, input);
-      const caller = createProcedureCaller({
+      const caller = createProcedureClient({
         context,
         procedure,
         path
@@ -88,8 +81,8 @@ var pendingCache = /* @__PURE__ */ new Map();
 function createResolveRouter(createHonoRouter) {
   const addRoutes = (routing, pending, options) => {
     const lazies = eachContractProcedureLeaf(options, ({ path, contract }) => {
-      const method = contract.zz$cp.method ?? "POST";
-      const httpPath = contract.zz$cp.path ? openAPIPathToRouterPath(contract.zz$cp.path) : `/${path.map(encodeURIComponent).join("/")}`;
+      const method = contract["~orpc"].route?.method ?? "POST";
+      const httpPath = contract["~orpc"].route?.path ? openAPIPathToRouterPath(contract["~orpc"].route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
       routing.add(method, httpPath, path);
     });
     pending.ref.push(...lazies);
@@ -114,7 +107,8 @@ function createResolveRouter(createHonoRouter) {
     })();
     const newPending = [];
     for (const item of pending.ref) {
-      if (LAZY_ROUTER_PREFIX_SYMBOL in item.lazy && item.lazy[LAZY_ROUTER_PREFIX_SYMBOL] && !pathname.startsWith(item.lazy[LAZY_ROUTER_PREFIX_SYMBOL]) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
+      const lazyPrefix = getLazyRouterPrefix(item.lazy);
+      if (lazyPrefix && !pathname.startsWith(lazyPrefix) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
         newPending.push(item);
         continue;
       }
@@ -134,20 +128,16 @@ function createResolveRouter(createHonoRouter) {
       match[1],
       (v) => params_[v]
     ) : match[1];
-    let current = router;
-    for (const segment of path) {
-      if (typeof current !== "object" && typeof current !== "function" || !current) {
-        current = void 0;
-        break;
-      }
-      current = current[segment];
+    const { default: maybeProcedure } = await unlazy(getRouterChild(router, ...path));
+    if (!isProcedure(maybeProcedure)) {
+      return void 0;
     }
-    return isProcedure(current) || isLazy(current) ? {
+    return {
       path,
-      procedure: current,
+      procedure: maybeProcedure,
       params: { ...params }
       // params from hono not a normal object, so we need spread here
-    } : void 0;
+    };
   };
 }
 function mergeParamsAndInput(coercedParams, input) {
@@ -164,7 +154,7 @@ function mergeParamsAndInput(coercedParams, input) {
 }
 async function deserializeInput(request, procedure) {
   const deserializer = new OpenAPIDeserializer({
-    schema: procedure.zz$p.contract.zz$cp.InputSchema
+    schema: procedure["~orpc"].contract["~orpc"].InputSchema
   });
   try {
     return await deserializer.deserialize(request);
@@ -702,7 +692,6 @@ export {
   createOpenAPIHandler,
   createOpenAPIServerHandler,
   createOpenAPIServerlessHandler,
-  createResolveRouter,
-  openAPIPathToRouterPath
+  createResolveRouter
 };
 //# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,10 +1,11 @@
 import {
-  eachContractProcedureLeaf
-} from "./chunk-KZIT2WCV.js";
+  eachContractProcedureLeaf,
+  standardizeHTTPPath
+} from "./chunk-CMRY2Z4J.js";
 
 // src/generator.ts
 import { isContractProcedure } from "@orpc/contract";
-import { LAZY_LOADER_SYMBOL } from "@orpc/server";
+import { unlazy } from "@orpc/server";
 import { findDeepMatches, isPlainObject, omit } from "@orpc/shared";
 import { preSerialize } from "@orpc/transformer";
 import {
@@ -3943,10 +3944,15 @@ var NON_LOGIC_KEYWORDS = [
 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?.isHandledCustomJSONSchema) {
-    const customJSONSchema = getCustomJSONSchema(schema._def, options);
+    const customJSONSchema = getCustomJSONSchema(schema__._def, options);
     if (customJSONSchema) {
-      const json = zodToJsonSchema(schema, {
+      const json = zodToJsonSchema(schema__, {
         ...options,
         isHandledCustomJSONSchema: true
       });
@@ -3957,13 +3963,13 @@ function zodToJsonSchema(schema, options) {
     }
   }
   const childOptions = { ...options, isHandledCustomJSONSchema: false };
-  const customType = getCustomZodType(schema._def);
+  const customType = getCustomZodType(schema__._def);
   switch (customType) {
     case "Blob": {
       return { type: "string", contentMediaType: "*/*" };
     }
     case "File": {
-      const mimeType = getCustomZodFileMimeType(schema._def) ?? "*/*";
+      const mimeType = getCustomZodFileMimeType(schema__._def) ?? "*/*";
       return { type: "string", contentMediaType: mimeType };
     }
     case "Invalid Date": {
@@ -3980,10 +3986,10 @@ function zodToJsonSchema(schema, options) {
     }
   }
   const _expectedCustomType = customType;
-  const typeName = schema._def.typeName;
+  const typeName = schema__._def.typeName;
   switch (typeName) {
     case ZodFirstPartyTypeKind.ZodString: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "string" };
       for (const check of schema_._def.checks) {
         switch (check.kind) {
@@ -4065,7 +4071,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodNumber: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "number" };
       for (const check of schema_._def.checks) {
         switch (check.kind) {
@@ -4110,23 +4116,23 @@ function zodToJsonSchema(schema, options) {
       return UNDEFINED_JSON_SCHEMA;
     }
     case ZodFirstPartyTypeKind.ZodLiteral: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return { const: schema_._def.value };
     }
     case ZodFirstPartyTypeKind.ZodEnum: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         enum: schema_._def.values
       };
     }
     case ZodFirstPartyTypeKind.ZodNativeEnum: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         enum: Object.values(schema_._def.values)
       };
     }
     case ZodFirstPartyTypeKind.ZodArray: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const def = schema_._def;
       const json = { type: "array" };
       if (def.exactLength) {
@@ -4142,7 +4148,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodTuple: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const prefixItems = [];
       const json = { type: "array" };
       for (const item of schema_._def.items) {
@@ -4160,7 +4166,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodObject: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "object" };
       const properties = {};
       const required = [];
@@ -4196,7 +4202,7 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodRecord: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const json = { type: "object" };
       json.additionalProperties = zodToJsonSchema(
         schema_._def.valueType,
@@ -4205,14 +4211,14 @@ function zodToJsonSchema(schema, options) {
       return json;
     }
     case ZodFirstPartyTypeKind.ZodSet: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         type: "array",
         items: zodToJsonSchema(schema_._def.valueType, childOptions)
       };
     }
     case ZodFirstPartyTypeKind.ZodMap: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return {
         type: "array",
         items: {
@@ -4228,7 +4234,7 @@ function zodToJsonSchema(schema, options) {
     }
     case ZodFirstPartyTypeKind.ZodUnion:
     case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const anyOf = [];
       for (const s of schema_._def.options) {
         anyOf.push(zodToJsonSchema(s, childOptions));
@@ -4236,7 +4242,7 @@ function zodToJsonSchema(schema, options) {
       return { anyOf };
     }
     case ZodFirstPartyTypeKind.ZodIntersection: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const allOf = [];
       for (const s of [schema_._def.left, schema_._def.right]) {
         allOf.push(zodToJsonSchema(s, childOptions));
@@ -4244,7 +4250,7 @@ function zodToJsonSchema(schema, options) {
       return { allOf };
     }
     case ZodFirstPartyTypeKind.ZodLazy: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const maxLazyDepth = childOptions?.maxLazyDepth ?? 5;
       const lazyDepth = childOptions?.lazyDepth ?? 0;
       if (lazyDepth > maxLazyDepth) {
@@ -4261,44 +4267,44 @@ function zodToJsonSchema(schema, options) {
       return {};
     }
     case ZodFirstPartyTypeKind.ZodOptional: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
       return {
         anyOf: [UNDEFINED_JSON_SCHEMA, inner]
       };
     }
     case ZodFirstPartyTypeKind.ZodReadonly: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodDefault: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodEffects: {
-      const schema_ = schema;
+      const schema_ = schema__;
       if (schema_._def.effect.type === "transform" && childOptions?.mode === "output") {
         return {};
       }
       return zodToJsonSchema(schema_._def.schema, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodCatch: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.innerType, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodBranded: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(schema_._def.type, childOptions);
     }
     case ZodFirstPartyTypeKind.ZodPipeline: {
-      const schema_ = schema;
+      const schema_ = schema__;
       return zodToJsonSchema(
         childOptions?.mode === "output" ? schema_._def.out : schema_._def.in,
         childOptions
       );
     }
     case ZodFirstPartyTypeKind.ZodNullable: {
-      const schema_ = schema;
+      const schema_ = schema__;
       const inner = zodToJsonSchema(schema_._def.innerType, childOptions);
       return {
         anyOf: [{ type: "null" }, inner]
@@ -4367,12 +4373,12 @@ async function generateOpenAPI(opts, options) {
       if (!isContractProcedure(contract)) {
         return;
       }
-      const internal = contract.zz$cp;
-      if (ignoreUndefinedPathProcedures && internal.path === void 0) {
+      const internal = contract["~orpc"];
+      if (ignoreUndefinedPathProcedures && internal.route?.path === void 0) {
         return;
       }
-      const httpPath = internal.path ?? `/${path.map(encodeURIComponent).join("/")}`;
-      const method = internal.method ?? "POST";
+      const httpPath = internal.route?.path ? standardizeHTTPPath(internal.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+      const method = internal.route?.method ?? "POST";
       let inputSchema = internal.InputSchema ? zodToJsonSchema(internal.InputSchema, { mode: "input" }) : {};
       const outputSchema = internal.OutputSchema ? zodToJsonSchema(internal.OutputSchema, { mode: "output" }) : {};
       const params = (() => {
@@ -4507,7 +4513,9 @@ async function generateOpenAPI(opts, options) {
           };
         }
         return {
-          required: Boolean(internal.InputSchema?.isOptional()),
+          required: Boolean(
+            internal.InputSchema && "isOptional" in internal.InputSchema && typeof internal.InputSchema.isOptional === "function" ? internal.InputSchema.isOptional() : false
+          ),
           content
         };
       })();
@@ -4532,8 +4540,8 @@ async function generateOpenAPI(opts, options) {
           content
         };
       })();
-      if (throwOnMissingTagDefinition && internal.tags) {
-        const missingTag = internal.tags.find((tag) => !rootTags.includes(tag));
+      if (throwOnMissingTagDefinition && internal.route?.tags) {
+        const missingTag = internal.route?.tags.find((tag) => !rootTags.includes(tag));
         if (missingTag !== void 0) {
           throw new Error(
             `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path.join(".")}]`
@@ -4541,10 +4549,10 @@ async function generateOpenAPI(opts, options) {
         }
       }
       const operation = {
-        summary: internal.summary,
-        description: internal.description,
-        deprecated: internal.deprecated,
-        tags: internal.tags,
+        summary: internal.route?.summary,
+        description: internal.route?.description,
+        deprecated: internal.route?.deprecated,
+        tags: internal.route?.tags ? [...internal.route.tags] : void 0,
         operationId: path.join("."),
         parameters: parameters.length ? parameters : void 0,
         requestBody,
@@ -4557,7 +4565,7 @@ async function generateOpenAPI(opts, options) {
       });
     });
     for (const lazy of lazies) {
-      const router = (await lazy.lazy[LAZY_LOADER_SYMBOL]()).default;
+      const { default: router } = await unlazy(lazy.lazy);
       pending.push({
         path: lazy.path,
         router

package/dist/src/fetch/base-handler.d.ts

@@ -1,15 +1,13 @@
-import type { HTTPPath } from '@orpc/contract';
-import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Router } from '@orpc/server';
+import type { ANY_PROCEDURE, ANY_ROUTER } from '@orpc/server';
 import type { FetchHandler } from '@orpc/server/fetch';
 import type { Router as HonoRouter } from 'hono/router';
-export type ResolveRouter = (router: Router<any>, method: string, pathname: string) => Promise<{
+export type ResolveRouter = (router: ANY_ROUTER, method: string, pathname: string) => Promise<{
     path: string[];
-    procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE;
+    procedure: ANY_PROCEDURE;
     params: Record<string, string>;
 } | undefined>;
 type Routing = HonoRouter<string[]>;
 export declare function createOpenAPIHandler(createHonoRouter: () => Routing): FetchHandler;
 export declare function createResolveRouter(createHonoRouter: () => Routing): ResolveRouter;
-export declare function openAPIPathToRouterPath(path: HTTPPath): string;
 export {};
 //# sourceMappingURL=base-handler.d.ts.map

package/dist/src/generator.d.ts

@@ -1,5 +1,5 @@
 import { type ContractRouter } from '@orpc/contract';
-import { type Router } from '@orpc/server';
+import { type ANY_ROUTER } from '@orpc/server';
 import { type OpenAPIObject } from 'openapi3-ts/oas31';
 export interface GenerateOpenAPIOptions {
     /**
@@ -19,6 +19,6 @@ export interface GenerateOpenAPIOptions {
     ignoreUndefinedPathProcedures?: boolean;
 }
 export declare function generateOpenAPI(opts: {
-    router: ContractRouter | Router<any>;
+    router: ContractRouter | ANY_ROUTER;
 } & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
 //# sourceMappingURL=generator.d.ts.map

package/dist/src/utils.d.ts

@@ -1,7 +1,7 @@
-import type { ContractProcedure, ContractRouter, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
-import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Lazy, Router } from '@orpc/server';
+import type { ContractRouter, HTTPPath, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { ANY_PROCEDURE, ANY_ROUTER, Lazy } from '@orpc/server';
 export interface EachLeafOptions {
-    router: ANY_PROCEDURE | Router<any> | ContractRouter | ContractProcedure<any, any>;
+    router: ContractRouter | ANY_ROUTER;
     path: string[];
 }
 export interface EachLeafCallbackOptions {
@@ -9,8 +9,9 @@ export interface EachLeafCallbackOptions {
     path: string[];
 }
 export interface EachContractLeafResultItem {
-    lazy: ANY_LAZY_PROCEDURE | Lazy<Router<any>>;
+    lazy: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER>>;
     path: string[];
 }
 export declare function eachContractProcedureLeaf(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+export declare function standardizeHTTPPath(path: HTTPPath): HTTPPath;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/zod-to-json-schema.d.ts

@@ -1,5 +1,5 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { type JSONSchema } from 'json-schema-typed/draft-2020-12';
-import { type ZodTypeAny } from 'zod';
 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: {};
@@ -35,7 +35,7 @@ export interface ZodToJsonSchemaOptions {
      */
     isHandledCustomJSONSchema?: boolean;
 }
-export declare function zodToJsonSchema(schema: ZodTypeAny, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
+export declare function zodToJsonSchema(schema: StandardSchemaV1, options?: ZodToJsonSchemaOptions): Exclude<JSONSchema, boolean>;
 export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JSONSchema) => boolean, matches?: JSONSchema[]): {
     schema: JSONSchema | undefined;
     matches: JSONSchema[];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -34,14 +34,15 @@
     "dist"
   ],
   "dependencies": {
+    "@standard-schema/spec": "1.0.0-beta.4",
     "escape-string-regexp": "^5.0.0",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "@orpc/server": "0.15.0",
-    "@orpc/contract": "0.15.0",
-    "@orpc/shared": "0.15.0",
-    "@orpc/transformer": "0.15.0",
-    "@orpc/zod": "0.15.0"
+    "@orpc/shared": "0.17.0",
+    "@orpc/server": "0.17.0",
+    "@orpc/transformer": "0.17.0",
+    "@orpc/zod": "0.17.0",
+    "@orpc/contract": "0.17.0"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",