@orpc/openapi 0.0.0-next.4a31e17 → 0.0.0-next.4e27480

package/dist/chunk-GEDPF5HA.js

@@ -0,0 +1,25 @@
+import {
+  OpenAPIHandler
+} from "./chunk-UG6W4GSA.js";
+
+// src/adapters/fetch/openapi-handler-server.ts
+import { TrieRouter } from "hono/router/trie-router";
+var OpenAPIServerHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new TrieRouter(), router, options);
+  }
+};
+
+// src/adapters/fetch/openapi-handler-serverless.ts
+import { LinearRouter } from "hono/router/linear-router";
+var OpenAPIServerlessHandler = class extends OpenAPIHandler {
+  constructor(router, options) {
+    super(new LinearRouter(), router, options);
+  }
+};
+
+export {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+};
+//# sourceMappingURL=chunk-GEDPF5HA.js.map

package/dist/{chunk-WNX6GP4X.js → chunk-UG6W4GSA.js}

@@ -2,7 +2,7 @@ import {
   JSONSerializer,
   forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-KNYXLM77.js";
+} from "./chunk-V4HFPIEN.js";
 
 // src/adapters/fetch/bracket-notation.ts
 import { isPlainObject } from "@orpc/shared";
@@ -402,7 +402,8 @@ var OpenAPIPayloadCodec = class {
 };
 
 // src/adapters/fetch/openapi-procedure-matcher.ts
-import { fallbackToGlobalConfig, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
+import { fallbackContractConfig } from "@orpc/contract";
+import { getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
 import { mapValues } from "@orpc/shared";
 var OpenAPIProcedureMatcher = class {
   constructor(hono, router) {
@@ -446,7 +447,7 @@ var OpenAPIProcedureMatcher = class {
   }
   add(path, router) {
     const lazies = forEachContractProcedure({ path, router }, ({ path: path2, contract }) => {
-      const method = fallbackToGlobalConfig("defaultMethod", contract["~orpc"].route?.method);
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route?.method);
       const httpPath = contract["~orpc"].route?.path ? this.convertOpenAPIPathToRouterPath(contract["~orpc"].route?.path) : `/${path2.map(encodeURIComponent).join("/")}`;
       this.hono.add(method, httpPath, [httpPath, path2]);
     });
@@ -485,8 +486,9 @@ var CompositeSchemaCoercer = class {
 };
 
 // src/adapters/fetch/openapi-handler.ts
-import { createProcedureClient, fallbackToGlobalConfig as fallbackToGlobalConfig2, ORPCError as ORPCError2 } from "@orpc/server";
-import { executeWithHooks, isPlainObject as isPlainObject3, ORPC_HANDLER_HEADER, trim } from "@orpc/shared";
+import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
+import { createProcedureClient, ORPCError as ORPCError2 } from "@orpc/server";
+import { executeWithHooks, isPlainObject as isPlainObject3, trim } from "@orpc/shared";
 var OpenAPIHandler = class {
   constructor(hono, router, options) {
     this.options = options;
@@ -502,13 +504,10 @@ var OpenAPIHandler = class {
   inputStructureCompact;
   inputStructureDetailed;
   compositeSchemaCoercer;
-  condition(request) {
-    return request.headers.get(ORPC_HANDLER_HEADER) === null;
-  }
-  async fetch(request, ...[options]) {
+  async handle(request, ...[options]) {
     const context = options?.context;
     const headers = request.headers;
-    const accept = headers.get("Accept") || void 0;
+    const accept = headers.get("accept") || void 0;
     const execute = async () => {
       const url = new URL(request.url);
       const pathname = `/${trim(url.pathname.replace(options?.prefix ?? "", ""), "/")}`;
@@ -517,22 +516,22 @@ var OpenAPIHandler = class {
       const matchedMethod = customMethod || request.method;
       const matched = await this.procedureMatcher.match(matchedMethod, pathname);
       if (!matched) {
-        throw new ORPCError2({ code: "NOT_FOUND", message: "Not found" });
+        return { matched: false, response: void 0 };
       }
       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({
+      const client = createProcedureClient(matched.procedure, {
         context,
-        procedure: matched.procedure,
         path: matched.path
       });
-      const output = await client(coercedInput, { signal: options?.signal });
+      const output = await client(coercedInput, { signal: request.signal });
       const { body, headers: resHeaders } = this.encodeOutput(matched.procedure, output, accept);
-      return new Response(body, {
+      const response = new Response(body, {
         headers: resHeaders,
-        status: fallbackToGlobalConfig2("defaultSuccessStatus", contractDef.route?.successStatus)
+        status: fallbackContractConfig2("defaultSuccessStatus", contractDef.route?.successStatus)
       });
+      return { matched: true, response };
     };
     try {
       return await executeWithHooks({
@@ -541,29 +540,31 @@ var OpenAPIHandler = class {
         input: request,
         hooks: this.options,
         meta: {
-          signal: options?.signal
+          signal: request.signal
         }
       });
     } catch (e) {
       const error = this.convertToORPCError(e);
       try {
         const { body, headers: headers2 } = this.payloadCodec.encode(error.toJSON(), accept);
-        return new Response(body, {
+        const response = new Response(body, {
           status: error.status,
           headers: headers2
         });
+        return { matched: true, response };
       } catch (e2) {
         const error2 = this.convertToORPCError(e2);
         const { body, headers: headers2 } = this.payloadCodec.encode(error2.toJSON(), void 0);
-        return new Response(body, {
+        const response = new Response(body, {
           status: error2.status,
           headers: headers2
         });
+        return { matched: true, response };
       }
     }
   }
   async decodeInput(procedure, params, request) {
-    const inputStructure = fallbackToGlobalConfig2("defaultInputStructure", procedure["~orpc"].contract["~orpc"].route?.inputStructure);
+    const inputStructure = fallbackContractConfig2("defaultInputStructure", procedure["~orpc"].contract["~orpc"].route?.inputStructure);
     const url = new URL(request.url);
     const query = url.searchParams;
     const headers = request.headers;
@@ -579,7 +580,7 @@ var OpenAPIHandler = class {
     return this.inputStructureDetailed.build(params, decodedQuery, decodedHeaders, decodedBody);
   }
   encodeOutput(procedure, output, accept) {
-    const outputStructure = fallbackToGlobalConfig2("defaultOutputStructure", procedure["~orpc"].contract["~orpc"].route?.outputStructure);
+    const outputStructure = fallbackContractConfig2("defaultOutputStructure", procedure["~orpc"].contract["~orpc"].route?.outputStructure);
     if (outputStructure === "compact") {
       return this.payloadCodec.encode(output, accept);
     }
@@ -649,4 +650,4 @@ export {
   CompositeSchemaCoercer,
   OpenAPIHandler
 };
-//# sourceMappingURL=chunk-WNX6GP4X.js.map
+//# sourceMappingURL=chunk-UG6W4GSA.js.map

package/dist/{chunk-KNYXLM77.js → chunk-V4HFPIEN.js}

@@ -104,4 +104,4 @@ export {
   forEachAllContractProcedure,
   standardizeHTTPPath
 };
-//# sourceMappingURL=chunk-KNYXLM77.js.map
+//# sourceMappingURL=chunk-V4HFPIEN.js.map

package/dist/fetch.js

@@ -1,3 +1,7 @@
+import {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-GEDPF5HA.js";
 import {
   CompositeSchemaCoercer,
   InputStructureCompact,
@@ -10,24 +14,8 @@ import {
   parsePath,
   serialize,
   stringifyPath
-} from "./chunk-WNX6GP4X.js";
-import "./chunk-KNYXLM77.js";
-
-// src/adapters/fetch/openapi-handler-server.ts
-import { TrieRouter } from "hono/router/trie-router";
-var OpenAPIServerHandler = class extends OpenAPIHandler {
-  constructor(router, options) {
-    super(new TrieRouter(), router, options);
-  }
-};
-
-// src/adapters/fetch/openapi-handler-serverless.ts
-import { LinearRouter } from "hono/router/linear-router";
-var OpenAPIServerlessHandler = class extends OpenAPIHandler {
-  constructor(router, options) {
-    super(new LinearRouter(), router, options);
-  }
-};
+} from "./chunk-UG6W4GSA.js";
+import "./chunk-V4HFPIEN.js";
 export {
   CompositeSchemaCoercer,
   InputStructureCompact,

package/dist/hono.js

@@ -0,0 +1,34 @@
+import {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-GEDPF5HA.js";
+import {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+} from "./chunk-UG6W4GSA.js";
+import "./chunk-V4HFPIEN.js";
+export {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+};
+//# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   forEachAllContractProcedure,
   forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-KNYXLM77.js";
+} from "./chunk-V4HFPIEN.js";
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -36,14 +36,15 @@ var OpenAPIContentBuilder = class {
 };
 
 // src/openapi-generator.ts
-import { fallbackToGlobalConfig as fallbackToGlobalConfig2 } from "@orpc/contract";
+import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
+import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
 var OpenAPIError = class extends Error {
 };
 
 // src/openapi-input-structure-parser.ts
-import { fallbackToGlobalConfig } from "@orpc/contract";
+import { fallbackContractConfig } from "@orpc/contract";
 var OpenAPIInputStructureParser = class {
   constructor(schemaConverter, schemaUtils, pathParser) {
     this.schemaConverter = schemaConverter;
@@ -52,7 +53,7 @@ var OpenAPIInputStructureParser = class {
   }
   parse(contract, structure) {
     const inputSchema = this.schemaConverter.convert(contract["~orpc"].InputSchema, { strategy: "input" });
-    const method = fallbackToGlobalConfig("defaultMethod", contract["~orpc"].route?.method);
+    const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route?.method);
     const httpPath = contract["~orpc"].route?.path;
     if (this.schemaUtils.isAnySchema(inputSchema)) {
       return {
@@ -293,14 +294,14 @@ var SchemaUtils = class {
     return typeof schema === "object" && schema.type === "object";
   }
   isAnySchema(schema) {
-    return schema === true || Object.keys(schema).length === 0;
+    return schema === true || Object.keys(schema).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
   }
   isUndefinableSchema(schema) {
     const [matches] = this.filterSchemaBranches(schema, (schema2) => {
       if (typeof schema2 === "boolean") {
         return schema2;
       }
-      return Object.keys(schema2).length === 0;
+      return Object.keys(schema2).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
     });
     return matches.length > 0;
   }
@@ -384,6 +385,7 @@ var OpenAPIGenerator = class {
   errorHandlerStrategy;
   ignoreUndefinedPathProcedures;
   considerMissingTagDefinitionAsError;
+  strictErrorResponses;
   constructor(options) {
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
@@ -396,6 +398,7 @@ var OpenAPIGenerator = class {
     this.errorHandlerStrategy = options?.errorHandlerStrategy ?? "throw";
     this.ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
     this.considerMissingTagDefinitionAsError = options?.considerMissingTagDefinitionAsError ?? false;
+    this.strictErrorResponses = options?.strictErrorResponses ?? true;
   }
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
@@ -409,10 +412,10 @@ var OpenAPIGenerator = class {
         if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
           return;
         }
-        const method = fallbackToGlobalConfig2("defaultMethod", def.route?.method);
+        const method = fallbackContractConfig2("defaultMethod", def.route?.method);
         const httpPath = def.route?.path ? standardizeHTTPPath(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
-        const inputStructure = fallbackToGlobalConfig2("defaultInputStructure", def.route?.inputStructure);
-        const outputStructure = fallbackToGlobalConfig2("defaultOutputStructure", def.route?.outputStructure);
+        const inputStructure = fallbackContractConfig2("defaultInputStructure", def.route?.inputStructure);
+        const outputStructure = fallbackContractConfig2("defaultOutputStructure", def.route?.outputStructure);
         const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
         const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
         const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
@@ -425,8 +428,9 @@ var OpenAPIGenerator = class {
           required: this.schemaUtils.isUndefinableSchema(bodySchema),
           content: this.contentBuilder.build(bodySchema)
         } : void 0;
-        const successResponse = {
-          description: fallbackToGlobalConfig2("defaultSuccessDescription", def.route?.successDescription),
+        const responses = {};
+        responses[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+          description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
           content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema, {
             example: def.outputExample
           }) : void 0,
@@ -434,6 +438,58 @@ var OpenAPIGenerator = class {
             example: def.outputExample
           }) : void 0
         };
+        const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
+          ...config,
+          code,
+          status: fallbackORPCErrorStatus(code, config?.status)
+        })), (error) => error.status);
+        for (const status in errors) {
+          const configs = errors[status];
+          if (!configs || configs.length === 0) {
+            continue;
+          }
+          const schemas = configs.map(({ data, code, message }) => {
+            const json = {
+              type: "object",
+              properties: {
+                defined: { const: true },
+                code: { const: code },
+                status: { const: Number(status) },
+                message: { type: "string", default: message },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            };
+            if (data) {
+              const dataJson = this.schemaConverter.convert(data, { strategy: "output" });
+              json.properties.data = dataJson;
+              if (!this.schemaUtils.isUndefinableSchema(dataJson)) {
+                json.required.push("data");
+              }
+            }
+            return json;
+          });
+          if (this.strictErrorResponses) {
+            schemas.push({
+              type: "object",
+              properties: {
+                defined: { const: false },
+                code: { type: "string" },
+                status: { type: "number" },
+                message: { type: "string" },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            });
+          }
+          const contentSchema = schemas.length === 1 ? schemas[0] : {
+            oneOf: schemas
+          };
+          responses[status] = {
+            description: status,
+            content: this.contentBuilder.build(contentSchema)
+          };
+        }
         if (this.considerMissingTagDefinitionAsError && def.route?.tags) {
           const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
           if (missingTag !== void 0) {
@@ -450,9 +506,7 @@ var OpenAPIGenerator = class {
           operationId: path.join("."),
           parameters: parameters.length ? parameters : void 0,
           requestBody,
-          responses: {
-            [fallbackToGlobalConfig2("defaultSuccessStatus", def.route?.successStatus)]: successResponse
-          }
+          responses
         };
         builder.addPath(httpPath, {
           [method.toLocaleLowerCase()]: operation

package/dist/next.js

@@ -0,0 +1,34 @@
+import {
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-GEDPF5HA.js";
+import {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+} from "./chunk-UG6W4GSA.js";
+import "./chunk-V4HFPIEN.js";
+export {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,25 +1,25 @@
 import {
   OpenAPIHandler
-} from "./chunk-WNX6GP4X.js";
-import "./chunk-KNYXLM77.js";
+} from "./chunk-UG6W4GSA.js";
+import "./chunk-V4HFPIEN.js";
 
 // src/adapters/node/openapi-handler.ts
-import { createRequest, sendResponse } from "@mjackson/node-fetch-server";
-import { ORPC_HANDLER_HEADER } from "@orpc/shared";
+import { createRequest, sendResponse } from "@orpc/server/node";
 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 request = createRequest(req, res);
     const castedOptions = options ?? {};
-    const response = await this.openapiFetchHandler.fetch(request, castedOptions);
-    await options?.beforeSend?.(response, castedOptions.context);
-    return await sendResponse(res, response);
+    const result = await this.openapiFetchHandler.handle(request, castedOptions);
+    if (result.matched === false) {
+      return { matched: false };
+    }
+    await options?.beforeSend?.(result.response, castedOptions.context);
+    await sendResponse(res, result.response);
+    return { matched: true };
   }
 };
 

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

@@ -1,5 +1,5 @@
 import type { Context, Router, WithSignal } from '@orpc/server';
-import type { ConditionalFetchHandler, FetchOptions } from '@orpc/server/fetch';
+import type { FetchHandler, FetchHandleRest, FetchHandleResult } from '@orpc/server/fetch';
 import type { PublicInputStructureCompact } from './input-structure-compact';
 import { type Hooks } from '@orpc/shared';
 import { type PublicJSONSerializer } from '../../json-serializer';
@@ -7,7 +7,7 @@ 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';
-export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response, T, WithSignal> & {
+export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, WithSignal> & {
     jsonSerializer?: PublicJSONSerializer;
     procedureMatcher?: PublicOpenAPIProcedureMatcher;
     payloadCodec?: PublicOpenAPIPayloadCodec;
@@ -15,7 +15,7 @@ export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, Response,
     inputBuilderFull?: PublicInputStructureDetailed;
     schemaCoercers?: SchemaCoercer[];
 };
-export declare class OpenAPIHandler<T extends Context> implements ConditionalFetchHandler<T> {
+export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
     private readonly options?;
     private readonly procedureMatcher;
     private readonly payloadCodec;
@@ -23,8 +23,7 @@ export declare class OpenAPIHandler<T extends Context> implements ConditionalFet
     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>;
+    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
     private decodeInput;
     private encodeOutput;
     private assertDetailedOutput;

package/dist/src/adapters/hono/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../fetch';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../fetch';
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,12 +1,11 @@
 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> {
+import { type RequestHandler, type RequestHandleRest, type RequestHandleResult } from '@orpc/server/node';
+export declare class OpenAPIHandler<T extends Context> implements RequestHandler<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>;
+    handle(req: IncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
 }
 //# sourceMappingURL=openapi-handler.d.ts.map

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

@@ -40,6 +40,12 @@ export interface OpenAPIGeneratorOptions {
      * @default 'throw'
      */
     errorHandlerStrategy?: ErrorHandlerStrategy;
+    /**
+     * Strict error response
+     *
+     * @default true
+     */
+    strictErrorResponses?: boolean;
 }
 export declare class OpenAPIGenerator {
     private readonly contentBuilder;
@@ -53,8 +59,9 @@ export declare class OpenAPIGenerator {
     private readonly errorHandlerStrategy;
     private readonly ignoreUndefinedPathProcedures;
     private readonly considerMissingTagDefinitionAsError;
+    private readonly strictErrorResponses;
     constructor(options?: OpenAPIGeneratorOptions);
-    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+    generate(router: ContractRouter<any> | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
 }
 export {};
 //# sourceMappingURL=openapi-generator.d.ts.map

package/dist/src/schema.d.ts

@@ -8,5 +8,5 @@ export type FileSchema = JSONSchema.JSONSchema & {
     type: 'string';
     contentMediaType: string;
 } & object;
-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 NON_LOGIC_KEYWORDS: string[];
 //# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.0.0-next.4a31e17",
+  "version": "0.0.0-next.4e27480",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -24,6 +24,16 @@
       "import": "./dist/fetch.js",
       "default": "./dist/fetch.js"
     },
+    "./hono": {
+      "types": "./dist/src/adapters/hono/index.d.ts",
+      "import": "./dist/hono.js",
+      "default": "./dist/hono.js"
+    },
+    "./next": {
+      "types": "./dist/src/adapters/next/index.d.ts",
+      "import": "./dist/next.js",
+      "default": "./dist/next.js"
+    },
     "./node": {
       "types": "./dist/src/adapters/node/index.d.ts",
       "import": "./dist/node.js",
@@ -39,7 +49,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mjackson/node-fetch-server": "^0.5.0",
     "@standard-schema/spec": "1.0.0-beta.4",
     "@types/content-disposition": "^0.5.8",
     "content-disposition": "^0.5.4",
@@ -49,16 +58,16 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/server": "0.0.0-next.4a31e17",
-    "@orpc/shared": "0.0.0-next.4a31e17",
-    "@orpc/contract": "0.0.0-next.4a31e17"
+    "@orpc/contract": "0.0.0-next.4e27480",
+    "@orpc/shared": "0.0.0-next.4e27480",
+    "@orpc/server": "0.0.0-next.4e27480"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/adapters/fetch/index.ts --entry.node=src/adapters/node/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }