@orpc/openapi 0.0.0-next.a09e9be → 0.0.0-next.a153125

package/dist/shared/openapi.B3hexduL.d.ts

@@ -0,0 +1,101 @@
+import { AnySchema, OpenAPI, AnyContractProcedure, AnyContractRouter } from '@orpc/contract';
+import { StandardOpenAPIJsonSerializerOptions } from '@orpc/openapi-client/standard';
+import { AnyProcedure, AnyRouter } from '@orpc/server';
+import { Promisable } from '@orpc/shared';
+import { JSONSchema } from 'json-schema-typed/draft-2020-12';
+
+interface SchemaConverterComponent {
+    allowedStrategies: readonly SchemaConvertOptions['strategy'][];
+    schema: AnySchema;
+    required: boolean;
+    ref: string;
+}
+interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+    /**
+     * Common components should use `$ref` to represent themselves if matched.
+     */
+    components?: readonly SchemaConverterComponent[];
+    /**
+     * Minimum schema structure depth required before using `$ref` for components.
+     *
+     * For example, if set to 2, `$ref` will only be used for schemas nested at depth 2 or greater.
+     *
+     * @default 0 - No depth limit;
+     */
+    minStructureDepthForRef?: number;
+}
+interface SchemaConverter {
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<[required: boolean, jsonSchema: JSONSchema]>;
+}
+interface ConditionalSchemaConverter extends SchemaConverter {
+    condition(schema: AnySchema | undefined, options: SchemaConvertOptions): Promisable<boolean>;
+}
+declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: ConditionalSchemaConverter[]);
+    convert(schema: AnySchema | undefined, options: SchemaConvertOptions): Promise<[required: boolean, jsonSchema: JSONSchema]>;
+}
+
+interface OpenAPIGeneratorOptions extends StandardOpenAPIJsonSerializerOptions {
+    schemaConverters?: ConditionalSchemaConverter[];
+}
+interface OpenAPIGeneratorGenerateOptions extends Partial<Omit<OpenAPI.Document, 'openapi'>> {
+    /**
+     * Exclude procedures from the OpenAPI specification.
+     *
+     * @default () => false
+     */
+    exclude?: (procedure: AnyProcedure | AnyContractProcedure, path: readonly string[]) => boolean;
+    /**
+     * Common schemas to be used for $ref resolution.
+     */
+    commonSchemas?: Record<string, {
+        /**
+         * Determines which schema definition to use when input and output schemas differ.
+         * This is needed because some schemas transform data differently between input and output,
+         * making it impossible to use a single $ref for both cases.
+         *
+         * @example
+         * ```ts
+         * // This schema transforms a string input into a number output
+         * const Schema = z.string()
+         *   .transform(v => Number(v))
+         *   .pipe(z.number())
+         *
+         * // Input schema:  { type: 'string' }
+         * // Output schema: { type: 'number' }
+         * ```
+         *
+         * When schemas differ between input and output, you must explicitly choose
+         * which version to use for the OpenAPI specification.
+         *
+         * @default 'input' - Uses the input schema definition by default
+         */
+        strategy?: SchemaConvertOptions['strategy'];
+        schema: AnySchema;
+    } | {
+        error: 'UndefinedError';
+        schema?: never;
+    }>;
+}
+/**
+ * The generator that converts oRPC routers/contracts to OpenAPI specifications.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
+ */
+declare class OpenAPIGenerator {
+    #private;
+    private readonly serializer;
+    private readonly converter;
+    constructor(options?: OpenAPIGeneratorOptions);
+    /**
+     * Generates OpenAPI specifications from oRPC routers/contracts.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
+     */
+    generate(router: AnyContractRouter | AnyRouter, options?: OpenAPIGeneratorGenerateOptions): Promise<OpenAPI.Document>;
+}
+
+export { OpenAPIGenerator as b, CompositeSchemaConverter as e };
+export type { ConditionalSchemaConverter as C, OpenAPIGeneratorOptions as O, SchemaConverterComponent as S, OpenAPIGeneratorGenerateOptions as a, SchemaConvertOptions as c, SchemaConverter as d };

package/dist/shared/{openapi.p5tsmBXx.mjs → openapi.C_UtQ8Us.mjs}

@@ -1,7 +1,8 @@
 import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, StandardBracketNotationSerializer, StandardOpenAPISerializer } from '@orpc/openapi-client/standard';
 import { StandardHandler } from '@orpc/server/standard';
+import { isORPCErrorStatus } from '@orpc/client';
 import { fallbackContractConfig } from '@orpc/contract';
-import { isObject } from '@orpc/shared';
+import { isObject, stringifyJSON } from '@orpc/shared';
 import { toHttpPath } from '@orpc/client/standard';
 import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@orpc/server';
 import { createRouter, addRoute, findRoute } from 'rou3';
@@ -52,13 +53,21 @@ class StandardOpenAPICodec {
         body: this.serializer.serialize(output)
       };
     }
-    if (!isObject(output)) {
-      throw new Error(
-        'Invalid output structure for "detailed" output. Expected format: { body: any, headers?: Record<string, string | string[] | undefined> }'
-      );
+    if (!this.#isDetailedOutput(output)) {
+      throw new Error(`
+        Invalid "detailed" output structure:
+        \u2022 Expected an object with optional properties:
+          - status (number 200-399)
+          - headers (Record<string, string | string[]>)
+          - body (any)
+        \u2022 No extra keys allowed.
+
+        Actual value:
+          ${stringifyJSON(output)}
+      `);
     }
     return {
-      status: successStatus,
+      status: output.status ?? successStatus,
       headers: output.headers ?? {},
       body: this.serializer.serialize(output.body)
     };
@@ -70,6 +79,18 @@ class StandardOpenAPICodec {
       body: this.serializer.serialize(error.toJSON(), { outputFormat: "plain" })
     };
   }
+  #isDetailedOutput(output) {
+    if (!isObject(output)) {
+      return false;
+    }
+    if (output.headers && !isObject(output.headers)) {
+      return false;
+    }
+    if (output.status !== void 0 && (typeof output.status !== "number" || !Number.isInteger(output.status) || isORPCErrorStatus(output.status))) {
+      return false;
+    }
+    return true;
+  }
 }
 
 function toRou3Pattern(path) {

package/dist/shared/{openapi.fMEQd3Yd.mjs → openapi.DrrBsJ0w.mjs}

@@ -1,10 +1,10 @@
-import { fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';
+import { isORPCErrorStatus, fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';
 import { toHttpPath } from '@orpc/client/standard';
 import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
 import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, getDynamicParams } from '@orpc/openapi-client/standard';
 import { isProcedure, resolveContractProcedures } from '@orpc/server';
-import { isObject, findDeepMatches, toArray, clone } from '@orpc/shared';
-import 'json-schema-typed/draft-2020-12';
+import { isObject, stringifyJSON, findDeepMatches, toArray, clone } from '@orpc/shared';
+import { TypeName } from 'json-schema-typed/draft-2020-12';
 
 const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
 function customOpenAPIOperation(o, extend) {
@@ -184,6 +184,57 @@ function applySchemaOptionality(required, schema) {
     ]
   };
 }
+function expandUnionSchema(schema) {
+  if (typeof schema === "object") {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every(
+        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
+      )) {
+        return schema[keyword].flatMap((s) => expandUnionSchema(s));
+      }
+    }
+  }
+  return [schema];
+}
+function expandArrayableSchema(schema) {
+  const schemas = expandUnionSchema(schema);
+  if (schemas.length !== 2) {
+    return void 0;
+  }
+  const arraySchema = schemas.find(
+    (s) => typeof s === "object" && s.type === "array" && Object.keys(s).filter((k) => LOGIC_KEYWORDS.includes(k)).every((k) => k === "type" || k === "items")
+  );
+  if (arraySchema === void 0) {
+    return void 0;
+  }
+  const items1 = arraySchema.items;
+  const items2 = schemas.find((s) => s !== arraySchema);
+  if (stringifyJSON(items1) !== stringifyJSON(items2)) {
+    return void 0;
+  }
+  return [items2, arraySchema];
+}
+const PRIMITIVE_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  TypeName.String,
+  TypeName.Number,
+  TypeName.Integer,
+  TypeName.Boolean,
+  TypeName.Null
+]);
+function isPrimitiveSchema(schema) {
+  return expandUnionSchema(schema).every((s) => {
+    if (typeof s === "boolean") {
+      return false;
+    }
+    if (typeof s.type === "string" && PRIMITIVE_SCHEMA_TYPES.has(s.type)) {
+      return true;
+    }
+    if (s.const !== void 0) {
+      return true;
+    }
+    return false;
+  });
+}
 
 function toOpenAPIPath(path) {
   return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
@@ -256,13 +307,26 @@ function toOpenAPIParameters(schema, parameterIn) {
   const parameters = [];
   for (const key in schema.properties) {
     const keySchema = schema.properties[key];
+    let isDeepObjectStyle = true;
+    if (parameterIn !== "query") {
+      isDeepObjectStyle = false;
+    } else if (isPrimitiveSchema(keySchema)) {
+      isDeepObjectStyle = false;
+    } else {
+      const [item] = expandArrayableSchema(keySchema) ?? [];
+      if (item !== void 0 && isPrimitiveSchema(item)) {
+        isDeepObjectStyle = false;
+      }
+    }
     parameters.push({
       name: key,
       in: parameterIn,
       required: schema.required?.includes(key),
-      style: parameterIn === "query" ? "deepObject" : void 0,
-      explode: parameterIn === "query" ? true : void 0,
-      schema: toOpenAPISchema(keySchema)
+      schema: toOpenAPISchema(keySchema),
+      style: isDeepObjectStyle ? "deepObject" : void 0,
+      explode: isDeepObjectStyle ? true : void 0,
+      allowEmptyValue: parameterIn === "query" ? true : void 0,
+      allowReserved: parameterIn === "query" ? true : void 0
     });
   }
   return parameters;
@@ -281,6 +345,15 @@ function checkParamsSchema(schema, params) {
 function toOpenAPISchema(schema) {
   return schema === true ? {} : schema === false ? { not: {} } : schema;
 }
+const OPENAPI_JSON_SCHEMA_REF_PREFIX = "#/components/schemas/";
+function resolveOpenAPIJsonSchemaRef(doc, schema) {
+  if (typeof schema !== "object" || !schema.$ref?.startsWith(OPENAPI_JSON_SCHEMA_REF_PREFIX)) {
+    return schema;
+  }
+  const name = schema.$ref.slice(OPENAPI_JSON_SCHEMA_REF_PREFIX.length);
+  const resolved = doc.components?.schemas?.[name];
+  return resolved ?? schema;
+}
 
 class CompositeSchemaConverter {
   converters;
@@ -312,14 +385,20 @@ class OpenAPIGenerator {
    * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
    */
   async generate(router, options = {}) {
+    const exclude = options.exclude ?? (() => false);
     const doc = {
       ...clone(options),
       info: options.info ?? { title: "API Reference", version: "0.0.0" },
-      openapi: "3.1.1"
+      openapi: "3.1.1",
+      exclude: void 0,
+      commonSchemas: void 0
     };
+    const { baseSchemaConvertOptions, undefinedErrorJsonSchema } = await this.#resolveCommonSchemas(doc, options.commonSchemas);
     const contracts = [];
     await resolveContractProcedures({ path: [], router }, ({ contract, path }) => {
-      contracts.push({ contract, path });
+      if (!exclude(contract, path)) {
+        contracts.push({ contract, path });
+      }
     });
     const errors = [];
     for (const { contract, path } of contracts) {
@@ -328,16 +407,21 @@ class OpenAPIGenerator {
         const def = contract["~orpc"];
         const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
         const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));
-        const operationObjectRef = {
-          operationId,
-          summary: def.route.summary,
-          description: def.route.description,
-          deprecated: def.route.deprecated,
-          tags: def.route.tags?.map((tag) => tag)
-        };
-        await this.#request(operationObjectRef, def);
-        await this.#successResponse(operationObjectRef, def);
-        await this.#errorResponse(operationObjectRef, def);
+        let operationObjectRef;
+        if (def.route.spec !== void 0) {
+          operationObjectRef = def.route.spec;
+        } else {
+          operationObjectRef = {
+            operationId,
+            summary: def.route.summary,
+            description: def.route.description,
+            deprecated: def.route.deprecated,
+            tags: def.route.tags?.map((tag) => tag)
+          };
+          await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
+          await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
+          await this.#errorResponse(operationObjectRef, def, baseSchemaConvertOptions, undefinedErrorJsonSchema);
+        }
         doc.paths ??= {};
         doc.paths[httpPath] ??= {};
         doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
@@ -360,22 +444,96 @@ ${errors.join("\n\n")}`
     }
     return this.serializer.serialize(doc)[0];
   }
-  async #request(ref, def) {
+  async #resolveCommonSchemas(doc, commonSchemas) {
+    let undefinedErrorJsonSchema = {
+      type: "object",
+      properties: {
+        defined: { const: false },
+        code: { type: "string" },
+        status: { type: "number" },
+        message: { type: "string" },
+        data: {}
+      },
+      required: ["defined", "code", "status", "message"]
+    };
+    const baseSchemaConvertOptions = {};
+    if (commonSchemas) {
+      baseSchemaConvertOptions.components = [];
+      for (const key in commonSchemas) {
+        const options = commonSchemas[key];
+        if (options.schema === void 0) {
+          continue;
+        }
+        const { schema, strategy = "input" } = options;
+        const [required, json] = await this.converter.convert(schema, { strategy });
+        const allowedStrategies = [strategy];
+        if (strategy === "input") {
+          const [outputRequired, outputJson] = await this.converter.convert(schema, { strategy: "output" });
+          if (outputRequired === required && stringifyJSON(outputJson) === stringifyJSON(json)) {
+            allowedStrategies.push("output");
+          }
+        } else if (strategy === "output") {
+          const [inputRequired, inputJson] = await this.converter.convert(schema, { strategy: "input" });
+          if (inputRequired === required && stringifyJSON(inputJson) === stringifyJSON(json)) {
+            allowedStrategies.push("input");
+          }
+        }
+        baseSchemaConvertOptions.components.push({
+          schema,
+          required,
+          ref: `#/components/schemas/${key}`,
+          allowedStrategies
+        });
+      }
+      doc.components ??= {};
+      doc.components.schemas ??= {};
+      for (const key in commonSchemas) {
+        const options = commonSchemas[key];
+        if (options.schema === void 0) {
+          if (options.error === "UndefinedError") {
+            doc.components.schemas[key] = toOpenAPISchema(undefinedErrorJsonSchema);
+            undefinedErrorJsonSchema = { $ref: `#/components/schemas/${key}` };
+          }
+          continue;
+        }
+        const { schema, strategy = "input" } = options;
+        const [, json] = await this.converter.convert(
+          schema,
+          {
+            ...baseSchemaConvertOptions,
+            strategy,
+            minStructureDepthForRef: 1
+            // not allow use $ref for root schemas
+          }
+        );
+        doc.components.schemas[key] = toOpenAPISchema(json);
+      }
+    }
+    return { baseSchemaConvertOptions, undefinedErrorJsonSchema };
+  }
+  async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
     const details = getEventIteratorSchemaDetails(def.inputSchema);
     if (details) {
       ref.requestBody = {
         required: true,
         content: toOpenAPIEventIteratorContent(
-          await this.converter.convert(details.yields, { strategy: "input" }),
-          await this.converter.convert(details.returns, { strategy: "input" })
+          await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
+          await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
         )
       };
       return;
     }
     const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
     const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
-    let [required, schema] = await this.converter.convert(def.inputSchema, { strategy: "input" });
+    let [required, schema] = await this.converter.convert(
+      def.inputSchema,
+      {
+        ...baseSchemaConvertOptions,
+        strategy: "input",
+        minStructureDepthForRef: dynamicParams?.length || inputStructure === "detailed" ? 1 : 0
+      }
+    );
     if (isAnySchema(schema) && !dynamicParams?.length) {
       return;
     }
@@ -418,7 +576,8 @@ ${errors.join("\n\n")}`
     if (!isObjectSchema(schema)) {
       throw error;
     }
-    if (dynamicParams?.length && (schema.properties?.params === void 0 || !isObjectSchema(schema.properties.params) || !checkParamsSchema(schema.properties.params, dynamicParams))) {
+    const resolvedParamSchema = schema.properties?.params !== void 0 ? resolveOpenAPIJsonSchemaRef(doc, schema.properties.params) : void 0;
+    if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) {
       throw new OpenAPIGeneratorError(
         'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
       );
@@ -426,12 +585,13 @@ ${errors.join("\n\n")}`
     for (const from of ["params", "query", "headers"]) {
       const fromSchema = schema.properties?.[from];
       if (fromSchema !== void 0) {
-        if (!isObjectSchema(fromSchema)) {
+        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, fromSchema);
+        if (!isObjectSchema(resolvedSchema)) {
           throw error;
         }
         const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
         ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(fromSchema, parameterIn));
+        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
       }
     }
     if (schema.properties?.body !== void 0) {
@@ -441,7 +601,7 @@ ${errors.join("\n\n")}`
       };
     }
   }
-  async #successResponse(ref, def) {
+  async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
     const outputSchema = def.outputSchema;
     const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
     const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
@@ -452,46 +612,90 @@ ${errors.join("\n\n")}`
       ref.responses[status] = {
         description,
         content: toOpenAPIEventIteratorContent(
-          await this.converter.convert(eventIteratorSchemaDetails.yields, { strategy: "output" }),
-          await this.converter.convert(eventIteratorSchemaDetails.returns, { strategy: "output" })
+          await this.converter.convert(eventIteratorSchemaDetails.yields, { ...baseSchemaConvertOptions, strategy: "output" }),
+          await this.converter.convert(eventIteratorSchemaDetails.returns, { ...baseSchemaConvertOptions, strategy: "output" })
         )
       };
       return;
     }
-    const [required, json] = await this.converter.convert(outputSchema, { strategy: "output" });
-    ref.responses ??= {};
-    ref.responses[status] = {
-      description
-    };
+    const [required, json] = await this.converter.convert(
+      outputSchema,
+      {
+        ...baseSchemaConvertOptions,
+        strategy: "output",
+        minStructureDepthForRef: outputStructure === "detailed" ? 1 : 0
+      }
+    );
     if (outputStructure === "compact") {
+      ref.responses ??= {};
+      ref.responses[status] = {
+        description
+      };
       ref.responses[status].content = toOpenAPIContent(applySchemaOptionality(required, json));
       return;
     }
-    const error = new OpenAPIGeneratorError(
-      'When output structure is "detailed", output schema must satisfy: { headers?: Record<string, unknown>, body?: unknown }'
-    );
-    if (!isObjectSchema(json)) {
-      throw error;
-    }
-    if (json.properties?.headers !== void 0) {
-      if (!isObjectSchema(json.properties.headers)) {
+    const handledStatuses = /* @__PURE__ */ new Set();
+    for (const item of expandUnionSchema(json)) {
+      const error = new OpenAPIGeneratorError(`
+        When output structure is "detailed", output schema must satisfy:
+        { 
+          status?: number, // must be a literal number and in the range of 200-399
+          headers?: Record<string, unknown>, 
+          body?: unknown 
+        }
+        
+        But got: ${stringifyJSON(item)}
+      `);
+      if (!isObjectSchema(item)) {
         throw error;
       }
-      for (const key in json.properties.headers.properties) {
-        ref.responses[status].headers ??= {};
-        ref.responses[status].headers[key] = {
-          schema: toOpenAPISchema(json.properties.headers.properties[key]),
-          required: json.properties.headers.required?.includes(key)
-        };
+      let schemaStatus;
+      let schemaDescription;
+      if (item.properties?.status !== void 0) {
+        const statusSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.status);
+        if (typeof statusSchema !== "object" || statusSchema.const === void 0 || typeof statusSchema.const !== "number" || !Number.isInteger(statusSchema.const) || isORPCErrorStatus(statusSchema.const)) {
+          throw error;
+        }
+        schemaStatus = statusSchema.const;
+        schemaDescription = statusSchema.description;
+      }
+      const itemStatus = schemaStatus ?? status;
+      const itemDescription = schemaDescription ?? description;
+      if (handledStatuses.has(itemStatus)) {
+        throw new OpenAPIGeneratorError(`
+          When output structure is "detailed", each success status must be unique.
+          But got status: ${itemStatus} used more than once.
+        `);
+      }
+      handledStatuses.add(itemStatus);
+      ref.responses ??= {};
+      ref.responses[itemStatus] = {
+        description: itemDescription
+      };
+      if (item.properties?.headers !== void 0) {
+        const headersSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.headers);
+        if (!isObjectSchema(headersSchema)) {
+          throw error;
+        }
+        for (const key in headersSchema.properties) {
+          const headerSchema = headersSchema.properties[key];
+          if (headerSchema !== void 0) {
+            ref.responses[itemStatus].headers ??= {};
+            ref.responses[itemStatus].headers[key] = {
+              schema: toOpenAPISchema(headerSchema),
+              required: item.required?.includes("headers") && headersSchema.required?.includes(key)
+            };
+          }
+        }
+      }
+      if (item.properties?.body !== void 0) {
+        ref.responses[itemStatus].content = toOpenAPIContent(
+          applySchemaOptionality(item.required?.includes("body") ?? false, item.properties.body)
+        );
       }
-    }
-    if (json.properties?.body !== void 0) {
-      ref.responses[status].content = toOpenAPIContent(
-        applySchemaOptionality(json.required?.includes("body") ?? false, json.properties.body)
-      );
     }
   }
-  async #errorResponse(ref, def) {
+  async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema) {
     const errorMap = def.errorMap;
     const errors = {};
     for (const code in errorMap) {
@@ -501,7 +705,7 @@ ${errors.join("\n\n")}`
       }
       const status = fallbackORPCErrorStatus(code, config.status);
       const message = fallbackORPCErrorMessage(code, config.message);
-      const [dataRequired, dataSchema] = await this.converter.convert(config.data, { strategy: "output" });
+      const [dataRequired, dataSchema] = await this.converter.convert(config.data, { ...baseSchemaConvertOptions, strategy: "output" });
       errors[status] ??= [];
       errors[status].push({
         type: "object",
@@ -523,17 +727,7 @@ ${errors.join("\n\n")}`
         content: toOpenAPIContent({
           oneOf: [
             ...schemas,
-            {
-              type: "object",
-              properties: {
-                defined: { const: false },
-                code: { type: "string" },
-                status: { type: "number" },
-                message: { type: "string" },
-                data: {}
-              },
-              required: ["defined", "code", "status", "message"]
-            }
+            undefinedErrorSchema
           ]
         })
       };
@@ -541,4 +735,4 @@ ${errors.join("\n\n")}`
   }
 }
 
-export { CompositeSchemaConverter as C, LOGIC_KEYWORDS as L, OpenAPIGenerator as O, applyCustomOpenAPIOperation as a, toOpenAPIMethod as b, customOpenAPIOperation as c, toOpenAPIContent as d, toOpenAPIEventIteratorContent as e, toOpenAPIParameters as f, getCustomOpenAPIOperation as g, checkParamsSchema as h, toOpenAPISchema as i, isFileSchema as j, isObjectSchema as k, isAnySchema as l, filterSchemaBranches as m, applySchemaOptionality as n, separateObjectSchema as s, toOpenAPIPath as t };
+export { CompositeSchemaConverter as C, LOGIC_KEYWORDS as L, OpenAPIGenerator as O, applyCustomOpenAPIOperation as a, toOpenAPIMethod as b, customOpenAPIOperation as c, toOpenAPIContent as d, toOpenAPIEventIteratorContent as e, toOpenAPIParameters as f, getCustomOpenAPIOperation as g, checkParamsSchema as h, toOpenAPISchema as i, isFileSchema as j, isObjectSchema as k, isAnySchema as l, filterSchemaBranches as m, applySchemaOptionality as n, expandUnionSchema as o, expandArrayableSchema as p, isPrimitiveSchema as q, resolveOpenAPIJsonSchemaRef as r, separateObjectSchema as s, toOpenAPIPath as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.a09e9be",
+  "version": "0.0.0-next.a153125",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -38,6 +38,11 @@
       "types": "./dist/adapters/node/index.d.mts",
       "import": "./dist/adapters/node/index.mjs",
       "default": "./dist/adapters/node/index.mjs"
+    },
+    "./aws-lambda": {
+      "types": "./dist/adapters/aws-lambda/index.d.mts",
+      "import": "./dist/adapters/aws-lambda/index.mjs",
+      "default": "./dist/adapters/aws-lambda/index.mjs"
     }
   },
   "files": [
@@ -45,17 +50,16 @@
   ],
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "openapi-types": "^12.1.3",
-    "rou3": "^0.6.0",
-    "@orpc/client": "0.0.0-next.a09e9be",
-    "@orpc/contract": "0.0.0-next.a09e9be",
-    "@orpc/openapi-client": "0.0.0-next.a09e9be",
-    "@orpc/standard-server": "0.0.0-next.a09e9be",
-    "@orpc/shared": "0.0.0-next.a09e9be",
-    "@orpc/server": "0.0.0-next.a09e9be"
+    "rou3": "^0.7.2",
+    "@orpc/client": "0.0.0-next.a153125",
+    "@orpc/openapi-client": "0.0.0-next.a153125",
+    "@orpc/server": "0.0.0-next.a153125",
+    "@orpc/shared": "0.0.0-next.a153125",
+    "@orpc/standard-server": "0.0.0-next.a153125",
+    "@orpc/contract": "0.0.0-next.a153125"
   },
   "devDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^3.25.67"
   },
   "scripts": {
     "build": "unbuild",