@orpc/openapi 0.22.0 → 0.24.0

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
@@ -218,21 +369,30 @@ var SchemaUtils = class {
 
 // src/openapi-generator.ts
 var OpenAPIGenerator = class {
+  contentBuilder;
+  parametersBuilder;
+  schemaConverter;
+  schemaUtils;
+  jsonSerializer;
+  pathParser;
+  inputStructureParser;
+  outputStructureParser;
+  errorHandlerStrategy;
+  ignoreUndefinedPathProcedures;
+  considerMissingTagDefinitionAsError;
   constructor(options) {
-    this.options = options;
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
     this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
     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);
+    this.errorHandlerStrategy = options?.errorHandlerStrategy ?? "throw";
+    this.ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
+    this.considerMissingTagDefinitionAsError = options?.considerMissingTagDefinitionAsError ?? false;
   }
-  contentBuilder;
-  parametersBuilder;
-  schemaConverter;
-  schemaUtils;
-  jsonSerializer;
-  pathParser;
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
       ...doc,
@@ -240,108 +400,76 @@ 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.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.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.errorHandlerStrategy === "throw") {
+            throw error;
+          }
+          if (this.errorHandlerStrategy === "log") {
+            console.error(error);
+          }
+        } else {
+          throw e;
         }
       }
-      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/node.js

@@ -0,0 +1,46 @@
+import {
+  OpenAPIHandler
+} from "./chunk-YXHH6XHB.js";
+import "./chunk-KNYXLM77.js";
+
+// src/adapters/node/openapi-handler.ts
+import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
+import { ORPC_HANDLER_HEADER } from "@orpc/shared";
+var OpenAPIHandler2 = class {
+  openapiFetchHandler;
+  constructor(hono, router, options) {
+    this.openapiFetchHandler = new OpenAPIHandler(hono, router, options);
+  }
+  condition(request) {
+    return request.headers[ORPC_HANDLER_HEADER] === void 0;
+  }
+  async handle(req, res, ...[options]) {
+    const request = createRequest(req, res, options);
+    const castedOptions = options ?? {};
+    const response = await this.openapiFetchHandler.fetch(request, castedOptions);
+    await options?.beforeSend?.(response, castedOptions.context);
+    return await sendResponse(res, response);
+  }
+};
+
+// src/adapters/node/openapi-handler-server.ts
+import { TrieRouter } from "hono/router/trie-router";
+var OpenAPIServerHandler = class extends OpenAPIHandler2 {
+  constructor(router, options) {
+    super(new TrieRouter(), router, options);
+  }
+};
+
+// src/adapters/node/openapi-handler-serverless.ts
+import { LinearRouter } from "hono/router/linear-router";
+var OpenAPIServerlessHandler = class extends OpenAPIHandler2 {
+  constructor(router, options) {
+    super(new LinearRouter(), router, options);
+  }
+};
+export {
+  OpenAPIHandler2 as OpenAPIHandler,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+};
+//# sourceMappingURL=node.js.map

package/dist/src/{fetch → adapters/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/adapters/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 → adapters/fetch/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 → adapters/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 PublicJSONSerializer } from '../../json-serializer';
+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 → adapters/fetch}/openapi-payload-codec.d.ts

@@ -1,8 +1,8 @@
-import type { PublicJSONSerializer } from '../json-serializer';
+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/adapters/node/index.d.ts

@@ -0,0 +1,5 @@
+export * from './openapi-handler';
+export * from './openapi-handler-server';
+export * from './openapi-handler-serverless';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/openapi-handler-server.d.ts

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-server.d.ts.map

package/dist/src/adapters/node/openapi-handler-serverless.d.ts

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import { OpenAPIHandler } from './openapi-handler';
+export declare class OpenAPIServerlessHandler<T extends Context> extends OpenAPIHandler<T> {
+    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+}
+//# sourceMappingURL=openapi-handler-serverless.d.ts.map

package/dist/src/adapters/node/openapi-handler.d.ts

@@ -0,0 +1,12 @@
+import type { Context, Router } from '@orpc/server';
+import type { ConditionalRequestHandler, RequestOptions } from '@orpc/server/node';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import type { Hono } from '../fetch/openapi-procedure-matcher';
+export declare class OpenAPIHandler<T extends Context> implements ConditionalRequestHandler<T> {
+    private readonly openapiFetchHandler;
+    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
+    condition(request: IncomingMessage): boolean;
+    handle(req: IncomingMessage, res: ServerResponse, ...[options]: [options: RequestOptions<T>] | (undefined extends T ? [] : never)): Promise<void>;
+}
+//# sourceMappingURL=openapi-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.d.ts.map

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';
@@ -7,6 +9,7 @@ import { type OpenAPI } from './openapi';
 import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';
 import { type PublicOpenAPIParametersBuilder } from './openapi-parameters-builder';
 import { type PublicSchemaUtils } from './schema-utils';
+type ErrorHandlerStrategy = 'throw' | 'log' | 'ignore';
 export interface OpenAPIGeneratorOptions {
     contentBuilder?: PublicOpenAPIContentBuilder;
     parametersBuilder?: PublicOpenAPIParametersBuilder;
@@ -14,6 +17,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
      *
@@ -30,22 +35,26 @@ export interface OpenAPIGeneratorOptions {
      */
     ignoreUndefinedPathProcedures?: boolean;
     /**
-     * Throw error when you have error in OpenAPI generator
+     * What to do when we found an error with our router
      *
-     * @default false
+     * @default 'throw'
      */
-    throwOnError?: boolean;
+    errorHandlerStrategy?: ErrorHandlerStrategy;
 }
 export declare class OpenAPIGenerator {
-    private readonly options?;
     private readonly contentBuilder;
     private readonly parametersBuilder;
     private readonly schemaConverter;
     private readonly schemaUtils;
     private readonly jsonSerializer;
     private readonly pathParser;
-    constructor(options?: OpenAPIGeneratorOptions | undefined);
+    private readonly inputStructureParser;
+    private readonly outputStructureParser;
+    private readonly errorHandlerStrategy;
+    private readonly ignoreUndefinedPathProcedures;
+    private readonly considerMissingTagDefinitionAsError;
+    constructor(options?: OpenAPIGeneratorOptions);
     generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
-    private handleError;
 }
+export {};
 //# 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