@orpc/openapi 0.21.0 → 0.23.0

package/dist/fetch.js

@@ -213,21 +213,9 @@ function parsePath(path) {
   return result;
 }
 
-// src/fetch/input-builder-full.ts
-var InputBuilderFull = class {
-  build(params, query, headers, body) {
-    return {
-      params,
-      query,
-      headers,
-      body
-    };
-  }
-};
-
-// src/fetch/input-builder-simple.ts
+// src/fetch/input-structure-compact.ts
 import { isPlainObject as isPlainObject2 } from "@orpc/shared";
-var InputBuilderSimple = class {
+var InputStructureCompact = class {
   build(params, payload) {
     if (Object.keys(params).length === 0) {
       return payload;
@@ -242,9 +230,21 @@ var InputBuilderSimple = class {
   }
 };
 
+// src/fetch/input-structure-detailed.ts
+var InputStructureDetailed = class {
+  build(params, query, headers, body) {
+    return {
+      params,
+      query,
+      headers,
+      body
+    };
+  }
+};
+
 // src/fetch/openapi-handler.ts
 import { createProcedureClient, ORPCError as ORPCError2 } from "@orpc/server";
-import { executeWithHooks, ORPC_HANDLER_HEADER, trim } from "@orpc/shared";
+import { executeWithHooks, isPlainObject as isPlainObject3, ORPC_HANDLER_HEADER, trim } from "@orpc/shared";
 
 // src/fetch/openapi-payload-codec.ts
 import { ORPCError } from "@orpc/server";
@@ -483,14 +483,14 @@ var OpenAPIHandler = class {
     const jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
     this.procedureMatcher = options?.procedureMatcher ?? new OpenAPIProcedureMatcher(hono, router);
     this.payloadCodec = options?.payloadCodec ?? new OpenAPIPayloadCodec(jsonSerializer);
-    this.inputBuilderSimple = options?.inputBuilderSimple ?? new InputBuilderSimple();
-    this.inputBuilderFull = options?.inputBuilderFull ?? new InputBuilderFull();
+    this.inputStructureCompact = options?.inputBuilderSimple ?? new InputStructureCompact();
+    this.inputStructureDetailed = options?.inputBuilderFull ?? new InputStructureDetailed();
     this.compositeSchemaCoercer = new CompositeSchemaCoercer(options?.schemaCoercers ?? []);
   }
   procedureMatcher;
   payloadCodec;
-  inputBuilderSimple;
-  inputBuilderFull;
+  inputStructureCompact;
+  inputStructureDetailed;
   compositeSchemaCoercer;
   condition(request) {
     return request.headers.get(ORPC_HANDLER_HEADER) === null;
@@ -504,24 +504,24 @@ var OpenAPIHandler = class {
       const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
       const query = url.searchParams;
       const customMethod = request.method === "POST" ? query.get("method")?.toUpperCase() : void 0;
-      const method = customMethod || request.method;
-      const match = await this.procedureMatcher.match(method, pathname);
-      if (!match) {
+      const matchedMethod = customMethod || request.method;
+      const matched = await this.procedureMatcher.match(matchedMethod, pathname);
+      if (!matched) {
         throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
       }
-      const decodedPayload = request.method === "GET" ? await this.payloadCodec.decode(query) : await this.payloadCodec.decode(request);
-      const input = this.inputBuilderSimple.build(match.params, decodedPayload);
-      const coercedInput = this.compositeSchemaCoercer.coerce(match.procedure["~orpc"].contract["~orpc"].InputSchema, input);
+      const contractDef = matched.procedure["~orpc"].contract["~orpc"];
+      const input = await this.decodeInput(matched.procedure, matched.params, request);
+      const coercedInput = this.compositeSchemaCoercer.coerce(contractDef.InputSchema, input);
       const client = createProcedureClient({
         context,
-        procedure: match.procedure,
-        path: match.path
+        procedure: matched.procedure,
+        path: matched.path
       });
       const output = await client(coercedInput, { signal: options?.signal });
-      const { body, headers: headers2 } = this.payloadCodec.encode(output);
+      const { body, headers: resHeaders } = this.encodeOutput(matched.procedure, output, accept);
       return new Response(body, {
-        headers: headers2,
-        status: match.procedure["~orpc"].contract["~orpc"].route?.successStatus ?? 200
+        headers: resHeaders,
+        status: contractDef.route?.successStatus ?? 200
       });
     };
     try {
@@ -544,7 +544,7 @@ var OpenAPIHandler = class {
         });
       } catch (e2) {
         const error2 = this.convertToORPCError(e2);
-        const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON());
+        const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON(), void 0);
         return new Response(body, {
           status: error2.status,
           headers: headers2
@@ -552,6 +552,73 @@ var OpenAPIHandler = class {
       }
     }
   }
+  async decodeInput(procedure, params, request) {
+    const inputStructure = procedure["~orpc"].contract["~orpc"].route?.inputStructure;
+    const url = new URL(request.url);
+    const query = url.searchParams;
+    const headers = request.headers;
+    if (!inputStructure || inputStructure === "compact") {
+      return this.inputStructureCompact.build(
+        params,
+        request.method === "GET" ? await this.payloadCodec.decode(query) : await this.payloadCodec.decode(request)
+      );
+    }
+    const _expect = inputStructure;
+    const decodedQuery = await this.payloadCodec.decode(query);
+    const decodedHeaders = await this.payloadCodec.decode(headers);
+    const decodedBody = await this.payloadCodec.decode(request);
+    return this.inputStructureDetailed.build(params, decodedQuery, decodedHeaders, decodedBody);
+  }
+  encodeOutput(procedure, output, accept) {
+    const outputStructure = procedure["~orpc"].contract["~orpc"].route?.outputStructure;
+    if (!outputStructure || outputStructure === "compact") {
+      return this.payloadCodec.encode(output, accept);
+    }
+    const _expect = outputStructure;
+    this.assertDetailedOutput(output);
+    const headers = new Headers();
+    if (output.headers) {
+      for (const [key, value] of Object.entries(output.headers)) {
+        headers.append(key, value);
+      }
+    }
+    const { body, headers: encodedHeaders } = this.payloadCodec.encode(output.body, accept);
+    if (encodedHeaders) {
+      for (const [key, value] of encodedHeaders.entries()) {
+        headers.append(key, value);
+      }
+    }
+    return { body, headers };
+  }
+  assertDetailedOutput(output) {
+    const error = new Error(`
+      Invalid output structure for 'detailed' output. 
+      Expected format:
+      {
+        body?: unknown;       // The main response content (optional)
+        headers?: {           // Additional headers (optional)
+          [key: string]: string;
+        };
+      }
+
+      Example:
+      {
+        body: { message: "Success" },
+        headers: { "X-Custom-Header": "Custom-Value" },
+      }
+
+      Fix: Ensure your output matches the expected structure.
+    `);
+    if (!isPlainObject3(output) || Object.keys(output).some((key) => key !== "body" && key !== "headers")) {
+      throw error;
+    }
+    if (output.headers !== void 0 && !isPlainObject3(output.headers)) {
+      throw error;
+    }
+    if (output.headers && Object.entries(output.headers).some(([key, value]) => typeof key !== "string" || typeof value !== "string")) {
+      throw error;
+    }
+  }
   convertToORPCError(e) {
     return e instanceof ORPCError2 ? e : new ORPCError2({
       code: "INTERNAL_SERVER_ERROR",
@@ -578,8 +645,8 @@ var OpenAPIServerlessHandler = class extends OpenAPIHandler {
 };
 export {
   CompositeSchemaCoercer,
-  InputBuilderFull,
-  InputBuilderSimple,
+  InputStructureCompact,
+  InputStructureDetailed,
   OpenAPIHandler,
   OpenAPIPayloadCodec,
   OpenAPIProcedureMatcher,

package/dist/index.js

@@ -35,8 +35,151 @@ var OpenAPIContentBuilder = class {
   }
 };
 
+// src/openapi-error.ts
+var OpenAPIError = class extends Error {
+};
+
+// src/openapi-input-structure-parser.ts
+var OpenAPIInputStructureParser = class {
+  constructor(schemaConverter, schemaUtils, pathParser) {
+    this.schemaConverter = schemaConverter;
+    this.schemaUtils = schemaUtils;
+    this.pathParser = pathParser;
+  }
+  parse(contract, structure) {
+    const inputSchema = this.schemaConverter.convert(contract["~orpc"].InputSchema, { strategy: "input" });
+    const method = contract["~orpc"].route?.method ?? "POST";
+    const httpPath = contract["~orpc"].route?.path;
+    if (this.schemaUtils.isAnySchema(inputSchema)) {
+      return {
+        paramsSchema: void 0,
+        querySchema: void 0,
+        headersSchema: void 0,
+        bodySchema: void 0
+      };
+    }
+    if (structure === "detailed") {
+      return this.parseDetailedSchema(inputSchema);
+    } else {
+      return this.parseCompactSchema(inputSchema, method, httpPath);
+    }
+  }
+  parseDetailedSchema(inputSchema) {
+    if (!this.schemaUtils.isObjectSchema(inputSchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', input schema must be an object.`);
+    }
+    if (inputSchema.properties && Object.keys(inputSchema.properties).some((key) => !["params", "query", "headers", "body"].includes(key))) {
+      throw new OpenAPIError(`When input structure is 'detailed', input schema must be only can contain 'params', 'query', 'headers' and 'body' properties.`);
+    }
+    let paramsSchema = inputSchema.properties?.params;
+    let querySchema = inputSchema.properties?.query;
+    let headersSchema = inputSchema.properties?.headers;
+    const bodySchema = inputSchema.properties?.body;
+    if (paramsSchema !== void 0 && this.schemaUtils.isAnySchema(paramsSchema)) {
+      paramsSchema = void 0;
+    }
+    if (paramsSchema !== void 0 && !this.schemaUtils.isObjectSchema(paramsSchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', params schema in input schema must be an object.`);
+    }
+    if (querySchema !== void 0 && this.schemaUtils.isAnySchema(querySchema)) {
+      querySchema = void 0;
+    }
+    if (querySchema !== void 0 && !this.schemaUtils.isObjectSchema(querySchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', query schema in input schema must be an object.`);
+    }
+    if (headersSchema !== void 0 && this.schemaUtils.isAnySchema(headersSchema)) {
+      headersSchema = void 0;
+    }
+    if (headersSchema !== void 0 && !this.schemaUtils.isObjectSchema(headersSchema)) {
+      throw new OpenAPIError(`When input structure is 'detailed', headers schema in input schema must be an object.`);
+    }
+    return { paramsSchema, querySchema, headersSchema, bodySchema };
+  }
+  parseCompactSchema(inputSchema, method, httpPath) {
+    const dynamic = httpPath ? this.pathParser.parseDynamicParams(httpPath) : [];
+    if (dynamic.length === 0) {
+      if (method === "GET") {
+        let querySchema = inputSchema;
+        if (querySchema !== void 0 && this.schemaUtils.isAnySchema(querySchema)) {
+          querySchema = void 0;
+        }
+        if (querySchema !== void 0 && !this.schemaUtils.isObjectSchema(querySchema)) {
+          throw new OpenAPIError(`When input structure is 'compact' and method is 'GET', input schema must be an object.`);
+        }
+        return {
+          paramsSchema: void 0,
+          querySchema,
+          headersSchema: void 0,
+          bodySchema: void 0
+        };
+      }
+      return {
+        paramsSchema: void 0,
+        querySchema: void 0,
+        headersSchema: void 0,
+        bodySchema: inputSchema
+      };
+    }
+    if (!this.schemaUtils.isObjectSchema(inputSchema)) {
+      throw new OpenAPIError(`When input structure is 'compact' and path has dynamic parameters, input schema must be an object.`);
+    }
+    const [params, rest] = this.schemaUtils.separateObjectSchema(inputSchema, dynamic.map((v) => v.name));
+    return {
+      paramsSchema: params,
+      querySchema: method === "GET" ? rest : void 0,
+      headersSchema: void 0,
+      bodySchema: method !== "GET" ? rest : void 0
+    };
+  }
+};
+
+// src/openapi-output-structure-parser.ts
+var OpenAPIOutputStructureParser = class {
+  constructor(schemaConverter, schemaUtils) {
+    this.schemaConverter = schemaConverter;
+    this.schemaUtils = schemaUtils;
+  }
+  parse(contract, structure) {
+    const outputSchema = this.schemaConverter.convert(contract["~orpc"].OutputSchema, { strategy: "output" });
+    if (this.schemaUtils.isAnySchema(outputSchema)) {
+      return {
+        headersSchema: void 0,
+        bodySchema: void 0
+      };
+    }
+    if (structure === "detailed") {
+      return this.parseDetailedSchema(outputSchema);
+    } else {
+      return this.parseCompactSchema(outputSchema);
+    }
+  }
+  parseDetailedSchema(outputSchema) {
+    if (!this.schemaUtils.isObjectSchema(outputSchema)) {
+      throw new OpenAPIError(`When output structure is 'detailed', output schema must be an object.`);
+    }
+    if (outputSchema.properties && Object.keys(outputSchema.properties).some((key) => !["headers", "body"].includes(key))) {
+      throw new OpenAPIError(`When output structure is 'detailed', output schema must be only can contain 'headers' and 'body' properties.`);
+    }
+    let headersSchema = outputSchema.properties?.headers;
+    const bodySchema = outputSchema.properties?.body;
+    if (headersSchema !== void 0 && this.schemaUtils.isAnySchema(headersSchema)) {
+      headersSchema = void 0;
+    }
+    if (headersSchema !== void 0 && !this.schemaUtils.isObjectSchema(headersSchema)) {
+      throw new OpenAPIError(`When output structure is 'detailed', headers schema in output schema must be an object.`);
+    }
+    return { headersSchema, bodySchema };
+  }
+  parseCompactSchema(outputSchema) {
+    return {
+      headersSchema: void 0,
+      bodySchema: outputSchema
+    };
+  }
+};
+
 // src/openapi-parameters-builder.ts
-import { get, isPlainObject } from "@orpc/shared";
+import { get, isPlainObject, omit } from "@orpc/shared";
 var OpenAPIParametersBuilder = class {
   build(paramIn, jsonSchema, options) {
     const parameters = [];
@@ -63,6 +206,14 @@ var OpenAPIParametersBuilder = class {
     }
     return parameters;
   }
+  buildHeadersObject(jsonSchema, options) {
+    const parameters = this.build("header", jsonSchema, options);
+    const headersObject = {};
+    for (const param of parameters) {
+      headersObject[param.name] = omit(param, ["name", "in"]);
+    }
+    return headersObject;
+  }
 };
 
 // src/openapi-path-parser.ts
@@ -226,6 +377,8 @@ var OpenAPIGenerator = class {
     this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
     this.contentBuilder = options?.contentBuilder ?? new OpenAPIContentBuilder(this.schemaUtils);
     this.pathParser = new OpenAPIPathParser();
+    this.inputStructureParser = options?.inputStructureParser ?? new OpenAPIInputStructureParser(this.schemaConverter, this.schemaUtils, this.pathParser);
+    this.outputStructureParser = options?.outputStructureParser ?? new OpenAPIOutputStructureParser(this.schemaConverter, this.schemaUtils);
   }
   contentBuilder;
   parametersBuilder;
@@ -233,6 +386,8 @@ var OpenAPIGenerator = class {
   schemaUtils;
   jsonSerializer;
   pathParser;
+  inputStructureParser;
+  outputStructureParser;
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
       ...doc,
@@ -240,108 +395,72 @@ var OpenAPIGenerator = class {
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
     await forEachAllContractProcedure(router, ({ contract, path }) => {
-      const def = contract["~orpc"];
-      if (this.options?.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
-        return;
-      }
-      const method = def.route?.method ?? "POST";
-      const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-      let inputSchema = this.schemaConverter.convert(def.InputSchema, { strategy: "input" });
-      const outputSchema = this.schemaConverter.convert(def.OutputSchema, { strategy: "output" });
-      const params = (() => {
-        const dynamic = this.pathParser.parseDynamicParams(httpPath);
-        if (!dynamic.length) {
-          return void 0;
-        }
-        if (this.schemaUtils.isAnySchema(inputSchema)) {
-          return void 0;
+      try {
+        const def = contract["~orpc"];
+        if (this.options?.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
+          return;
         }
-        if (!this.schemaUtils.isObjectSchema(inputSchema)) {
-          this.handleError(
-            new Error(
-              `When path has parameters, input schema must be an object [${path.join(".")}]`
-            )
-          );
-          return void 0;
-        }
-        const [matched, rest] = this.schemaUtils.separateObjectSchema(inputSchema, dynamic.map((v) => v.name));
-        inputSchema = rest;
-        return this.parametersBuilder.build("path", matched, {
-          example: def.inputExample,
+        const method = def.route?.method ?? "POST";
+        const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+        const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, def.route?.inputStructure ?? "compact");
+        const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, def.route?.outputStructure ?? "compact");
+        const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
           required: true
-        });
-      })();
-      const query = (() => {
-        if (method !== "GET" || Object.keys(inputSchema).length === 0) {
-          return void 0;
-        }
-        if (this.schemaUtils.isAnySchema(inputSchema)) {
-          return void 0;
-        }
-        if (!this.schemaUtils.isObjectSchema(inputSchema)) {
-          this.handleError(
-            new Error(
-              `When method is GET, input schema must be an object [${path.join(".")}]`
-            )
-          );
-          return void 0;
-        }
-        return this.parametersBuilder.build("query", inputSchema, {
-          example: def.inputExample
-        });
-      })();
-      const parameters = [...params ?? [], ...query ?? []];
-      const requestBody = (() => {
-        if (method === "GET") {
-          return void 0;
+        }) : [];
+        const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
+        const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
+        const parameters = [...params, ...query, ...headers];
+        const requestBody = bodySchema !== void 0 ? {
+          required: this.schemaUtils.isUndefinableSchema(bodySchema),
+          content: this.contentBuilder.build(bodySchema)
+        } : void 0;
+        const successResponse = {
+          description: "OK",
+          content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema, {
+            example: def.outputExample
+          }) : void 0,
+          headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema, {
+            example: def.outputExample
+          }) : void 0
+        };
+        if (this.options?.considerMissingTagDefinitionAsError && def.route?.tags) {
+          const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
+          if (missingTag !== void 0) {
+            throw new OpenAPIError(
+              `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object`
+            );
+          }
         }
-        return {
-          required: this.schemaUtils.isUndefinableSchema(inputSchema),
-          content: this.contentBuilder.build(inputSchema, {
-            example: def.inputExample
-          })
+        const operation = {
+          summary: def.route?.summary,
+          description: def.route?.description,
+          deprecated: def.route?.deprecated,
+          tags: def.route?.tags ? [...def.route.tags] : void 0,
+          operationId: path.join("."),
+          parameters: parameters.length ? parameters : void 0,
+          requestBody,
+          responses: {
+            [def.route?.successStatus ?? 200]: successResponse
+          }
         };
-      })();
-      const successResponse = {
-        description: "OK",
-        content: this.contentBuilder.build(outputSchema, {
-          example: def.outputExample
-        })
-      };
-      if (this.options?.considerMissingTagDefinitionAsError && def.route?.tags) {
-        const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
-        if (missingTag !== void 0) {
-          this.handleError(
-            new Error(
-              `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path.join(".")}]`
-            )
-          );
+        builder.addPath(httpPath, {
+          [method.toLocaleLowerCase()]: operation
+        });
+      } catch (e) {
+        if (e instanceof OpenAPIError) {
+          const error = new OpenAPIError(`
+            Generate OpenAPI Error: ${e.message}
+            Happened at path: ${path.join(".")}
+          `, { cause: e });
+          if (this.options?.throwOnError) {
+            throw error;
+          }
+          console.error(error);
         }
       }
-      const operation = {
-        summary: def.route?.summary,
-        description: def.route?.description,
-        deprecated: def.route?.deprecated,
-        tags: def.route?.tags ? [...def.route.tags] : void 0,
-        operationId: path.join("."),
-        parameters: parameters.length ? parameters : void 0,
-        requestBody,
-        responses: {
-          [def.route?.successStatus ?? 200]: successResponse
-        }
-      };
-      builder.addPath(httpPath, {
-        [method.toLocaleLowerCase()]: operation
-      });
     });
     return this.jsonSerializer.serialize(builder.getSpec());
   }
-  handleError(error) {
-    if (this.options?.throwOnError) {
-      throw error;
-    }
-    console.error(error);
-  }
 };
 export {
   CompositeSchemaConverter,

package/dist/src/fetch/index.d.ts

@@ -1,6 +1,6 @@
 export * from './bracket-notation';
-export * from './input-builder-full';
-export * from './input-builder-simple';
+export * from './input-structure-compact';
+export * from './input-structure-detailed';
 export * from './openapi-handler';
 export * from './openapi-handler-server';
 export * from './openapi-handler-serverless';

package/dist/src/fetch/input-structure-compact.d.ts

@@ -0,0 +1,6 @@
+import type { Params } from 'hono/router';
+export declare class InputStructureCompact {
+    build(params: Params, payload: unknown): unknown;
+}
+export type PublicInputStructureCompact = Pick<InputStructureCompact, keyof InputStructureCompact>;
+//# sourceMappingURL=input-structure-compact.d.ts.map

package/dist/src/fetch/{input-builder-full.d.ts → input-structure-detailed.d.ts}

@@ -1,5 +1,5 @@
 import type { Params } from 'hono/router';
-export declare class InputBuilderFull {
+export declare class InputStructureDetailed {
     build(params: Params, query: unknown, headers: unknown, body: unknown): {
         params: Params;
         query: unknown;
@@ -7,5 +7,5 @@ export declare class InputBuilderFull {
         body: unknown;
     };
 }
-export type PublicInputBuilderFull = Pick<InputBuilderFull, keyof InputBuilderFull>;
-//# sourceMappingURL=input-builder-full.d.ts.map
+export type PublicInputStructureDetailed = Pick<InputStructureDetailed, keyof InputStructureDetailed>;
+//# sourceMappingURL=input-structure-detailed.d.ts.map

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

@@ -1,9 +1,9 @@
+import type { Context, Router, WithSignal } from '@orpc/server';
 import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
-import type { PublicInputBuilderSimple } from './input-builder-simple';
-import { type Context, type Router, type WithSignal } from '@orpc/server';
+import type { PublicInputStructureCompact } from './input-structure-compact';
 import { type Hooks } from '@orpc/shared';
 import { type PublicJSONSerializer } from '../json-serializer';
-import { type PublicInputBuilderFull } from './input-builder-full';
+import { type PublicInputStructureDetailed } from './input-structure-detailed';
 import { type PublicOpenAPIPayloadCodec } from './openapi-payload-codec';
 import { type Hono, type PublicOpenAPIProcedureMatcher } from './openapi-procedure-matcher';
 import { type SchemaCoercer } from './schema-coercer';
@@ -11,20 +11,23 @@ export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response,
     jsonSerializer?: PublicJSONSerializer;
     procedureMatcher?: PublicOpenAPIProcedureMatcher;
     payloadCodec?: PublicOpenAPIPayloadCodec;
-    inputBuilderSimple?: PublicInputBuilderSimple;
-    inputBuilderFull?: PublicInputBuilderFull;
+    inputBuilderSimple?: PublicInputStructureCompact;
+    inputBuilderFull?: PublicInputStructureDetailed;
     schemaCoercers?: SchemaCoercer[];
 };
 export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
     private readonly options?;
     private readonly procedureMatcher;
     private readonly payloadCodec;
-    private readonly inputBuilderSimple;
-    private readonly inputBuilderFull;
+    private readonly inputStructureCompact;
+    private readonly inputStructureDetailed;
     private readonly compositeSchemaCoercer;
     constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
     condition(request: Request): boolean;
     fetch(request: Request, ...[options]: [options: FetchOptions<T>] | (undefined extends T ? [] : never)): Promise<Response>;
+    private decodeInput;
+    private encodeOutput;
+    private assertDetailedOutput;
     private convertToORPCError;
 }
 //# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/fetch/openapi-payload-codec.d.ts

@@ -2,7 +2,7 @@ import type { PublicJSONSerializer } from '../json-serializer';
 export declare class OpenAPIPayloadCodec {
     private readonly jsonSerializer;
     constructor(jsonSerializer: PublicJSONSerializer);
-    encode(payload: unknown, accept?: string): {
+    encode(payload: unknown, accept: string | undefined): {
         body: FormData | Blob | string | undefined;
         headers?: Headers;
     };

package/dist/src/openapi-error.d.ts

@@ -0,0 +1,3 @@
+export declare class OpenAPIError extends Error {
+}
+//# sourceMappingURL=openapi-error.d.ts.map

package/dist/src/openapi-generator.d.ts

@@ -1,5 +1,7 @@
 import type { ContractRouter } from '@orpc/contract';
 import type { ANY_ROUTER } from '@orpc/server';
+import type { PublicOpenAPIInputStructureParser } from './openapi-input-structure-parser';
+import type { PublicOpenAPIOutputStructureParser } from './openapi-output-structure-parser';
 import type { PublicOpenAPIPathParser } from './openapi-path-parser';
 import type { SchemaConverter } from './schema-converter';
 import { type PublicJSONSerializer } from './json-serializer';
@@ -14,6 +16,8 @@ export interface OpenAPIGeneratorOptions {
     schemaUtils?: PublicSchemaUtils;
     jsonSerializer?: PublicJSONSerializer;
     pathParser?: PublicOpenAPIPathParser;
+    inputStructureParser?: PublicOpenAPIInputStructureParser;
+    outputStructureParser?: PublicOpenAPIOutputStructureParser;
     /**
      * Throw error when you missing define tag definition on OpenAPI root tags
      *
@@ -44,8 +48,9 @@ export declare class OpenAPIGenerator {
     private readonly schemaUtils;
     private readonly jsonSerializer;
     private readonly pathParser;
+    private readonly inputStructureParser;
+    private readonly outputStructureParser;
     constructor(options?: OpenAPIGeneratorOptions | undefined);
     generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
-    private handleError;
 }
 //# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/openapi-input-structure-parser.d.ts

@@ -0,0 +1,22 @@
+import type { ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { PublicOpenAPIPathParser } from './openapi-path-parser';
+import type { JSONSchema, ObjectSchema } from './schema';
+import type { SchemaConverter } from './schema-converter';
+import type { PublicSchemaUtils } from './schema-utils';
+export interface OpenAPIInputStructureParseResult {
+    paramsSchema: ObjectSchema | undefined;
+    querySchema: ObjectSchema | undefined;
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+export declare class OpenAPIInputStructureParser {
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly pathParser;
+    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils, pathParser: PublicOpenAPIPathParser);
+    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
+    private parseDetailedSchema;
+    private parseCompactSchema;
+}
+export type PublicOpenAPIInputStructureParser = Pick<OpenAPIInputStructureParser, keyof OpenAPIInputStructureParser>;
+//# sourceMappingURL=openapi-input-structure-parser.d.ts.map

package/dist/src/openapi-output-structure-parser.d.ts

@@ -0,0 +1,18 @@
+import type { ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { JSONSchema, ObjectSchema } from './schema';
+import type { SchemaConverter } from './schema-converter';
+import type { PublicSchemaUtils } from './schema-utils';
+export interface OpenAPIOutputStructureParseResult {
+    headersSchema: ObjectSchema | undefined;
+    bodySchema: JSONSchema.JSONSchema | undefined;
+}
+export declare class OpenAPIOutputStructureParser {
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils);
+    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
+    private parseDetailedSchema;
+    private parseCompactSchema;
+}
+export type PublicOpenAPIOutputStructureParser = Pick<OpenAPIOutputStructureParser, keyof OpenAPIOutputStructureParser>;
+//# sourceMappingURL=openapi-output-structure-parser.d.ts.map

package/dist/src/openapi-parameters-builder.d.ts

@@ -4,6 +4,9 @@ export declare class OpenAPIParametersBuilder {
     build(paramIn: OpenAPI.ParameterObject['in'], jsonSchema: JSONSchema.JSONSchema & {
         type: 'object';
     } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.ParameterObject[];
+    buildHeadersObject(jsonSchema: JSONSchema.JSONSchema & {
+        type: 'object';
+    } & object, options?: Pick<OpenAPI.ParameterObject, 'example' | 'style' | 'required'>): OpenAPI.HeadersObject;
 }
 export type PublicOpenAPIParametersBuilder = Pick<OpenAPIParametersBuilder, keyof OpenAPIParametersBuilder>;
 //# sourceMappingURL=openapi-parameters-builder.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -43,9 +43,9 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.21.0",
-    "@orpc/shared": "0.21.0",
-    "@orpc/server": "0.21.0"
+    "@orpc/contract": "0.23.0",
+    "@orpc/shared": "0.23.0",
+    "@orpc/server": "0.23.0"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",

package/dist/src/fetch/input-builder-simple.d.ts

@@ -1,6 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputBuilderSimple {
-    build(params: Params, payload: unknown): unknown;
-}
-export type PublicInputBuilderSimple = Pick<InputBuilderSimple, keyof InputBuilderSimple>;
-//# sourceMappingURL=input-builder-simple.d.ts.map