@orpc/openapi 0.0.0-next.f22c7ec → 0.0.0-next.f56d2b3

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

@@ -35,7 +35,7 @@ var JSONSerializer = class {
 
 // src/utils.ts
 import { isContractProcedure } from "@orpc/contract";
-import { getRouterContract, isLazy, isProcedure, unlazy } from "@orpc/server";
+import { getRouterContract, isLazy, unlazy } from "@orpc/server";
 function forEachContractProcedure(options, callback, result = [], isCurrentRouterContract = false) {
   const hiddenContract = getRouterContract(options.router);
   if (!isCurrentRouterContract && hiddenContract) {
@@ -54,11 +54,6 @@ function forEachContractProcedure(options, callback, result = [], isCurrentRoute
       router: options.router,
       path: options.path
     });
-  } else if (isProcedure(options.router)) {
-    callback({
-      contract: options.router["~orpc"].contract,
-      path: options.path
-    });
   } else if (isContractProcedure(options.router)) {
     callback({
       contract: options.router,
@@ -104,4 +99,4 @@ export {
   forEachAllContractProcedure,
   standardizeHTTPPath
 };
-//# sourceMappingURL=chunk-V4HFPIEN.js.map
+//# sourceMappingURL=chunk-Q2LSK6YZ.js.map

package/dist/{chunk-TW72MGM2.js → chunk-SOVQ5ARD.js}

@@ -2,7 +2,7 @@ import {
   JSONSerializer,
   forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-V4HFPIEN.js";
+} from "./chunk-Q2LSK6YZ.js";
 
 // src/adapters/fetch/bracket-notation.ts
 import { isPlainObject } from "@orpc/shared";
@@ -288,8 +288,7 @@ var OpenAPIPayloadCodec = class {
     if (isExpectedMultipartFormData) {
       return this.encodeAsFormData(handledPayload);
     }
-    throw new ORPCError({
-      code: "NOT_ACCEPTABLE",
+    throw new ORPCError("NOT_ACCEPTABLE", {
       message: `Unsupported content-type: ${accept}`
     });
   }
@@ -392,8 +391,7 @@ var OpenAPIPayloadCodec = class {
         type: blob.type
       });
     } catch (e) {
-      throw new ORPCError({
-        code: "BAD_REQUEST",
+      throw new ORPCError("BAD_REQUEST", {
         message: "Cannot parse request/response. Please check the request/response body and Content-Type header.",
         cause: e
       });
@@ -402,7 +400,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 +445,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,7 +484,8 @@ var CompositeSchemaCoercer = class {
 };
 
 // src/adapters/fetch/openapi-handler.ts
-import { createProcedureClient, fallbackToGlobalConfig as fallbackToGlobalConfig2, ORPCError as ORPCError2 } from "@orpc/server";
+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) {
@@ -503,7 +503,7 @@ var OpenAPIHandler = class {
   inputStructureDetailed;
   compositeSchemaCoercer;
   async handle(request, ...[options]) {
-    const context = options?.context;
+    const context = options?.context ?? {};
     const headers = request.headers;
     const accept = headers.get("accept") || void 0;
     const execute = async () => {
@@ -516,9 +516,9 @@ var OpenAPIHandler = class {
       if (!matched) {
         return { matched: false, response: void 0 };
       }
-      const contractDef = matched.procedure["~orpc"].contract["~orpc"];
+      const def = matched.procedure["~orpc"];
       const input = await this.decodeInput(matched.procedure, matched.params, request);
-      const coercedInput = this.compositeSchemaCoercer.coerce(contractDef.InputSchema, input);
+      const coercedInput = this.compositeSchemaCoercer.coerce(def.inputSchema, input);
       const client = createProcedureClient(matched.procedure, {
         context,
         path: matched.path
@@ -527,7 +527,7 @@ var OpenAPIHandler = class {
       const { body, headers: resHeaders } = this.encodeOutput(matched.procedure, output, accept);
       const response = new Response(body, {
         headers: resHeaders,
-        status: fallbackToGlobalConfig2("defaultSuccessStatus", contractDef.route?.successStatus)
+        status: fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)
       });
       return { matched: true, response };
     };
@@ -562,7 +562,7 @@ var OpenAPIHandler = class {
     }
   }
   async decodeInput(procedure, params, request) {
-    const inputStructure = fallbackToGlobalConfig2("defaultInputStructure", procedure["~orpc"].contract["~orpc"].route?.inputStructure);
+    const inputStructure = fallbackContractConfig2("defaultInputStructure", procedure["~orpc"].route.inputStructure);
     const url = new URL(request.url);
     const query = url.searchParams;
     const headers = request.headers;
@@ -578,7 +578,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"].route.outputStructure);
     if (outputStructure === "compact") {
       return this.payloadCodec.encode(output, accept);
     }
@@ -627,8 +627,7 @@ var OpenAPIHandler = class {
     }
   }
   convertToORPCError(e) {
-    return e instanceof ORPCError2 ? e : new ORPCError2({
-      code: "INTERNAL_SERVER_ERROR",
+    return e instanceof ORPCError2 ? e : new ORPCError2("INTERNAL_SERVER_ERROR", {
       message: "Internal server error",
       cause: e
     });
@@ -648,4 +647,4 @@ export {
   CompositeSchemaCoercer,
   OpenAPIHandler
 };
-//# sourceMappingURL=chunk-TW72MGM2.js.map
+//# sourceMappingURL=chunk-SOVQ5ARD.js.map

package/dist/{chunk-N7JLIFHD.js → chunk-VFGNQS5W.js}

@@ -1,6 +1,6 @@
 import {
   OpenAPIHandler
-} from "./chunk-TW72MGM2.js";
+} from "./chunk-SOVQ5ARD.js";
 
 // src/adapters/fetch/openapi-handler-server.ts
 import { TrieRouter } from "hono/router/trie-router";
@@ -22,4 +22,4 @@ export {
   OpenAPIServerHandler,
   OpenAPIServerlessHandler
 };
-//# sourceMappingURL=chunk-N7JLIFHD.js.map
+//# sourceMappingURL=chunk-VFGNQS5W.js.map

package/dist/fetch.js

@@ -1,7 +1,7 @@
 import {
   OpenAPIServerHandler,
   OpenAPIServerlessHandler
-} from "./chunk-N7JLIFHD.js";
+} from "./chunk-VFGNQS5W.js";
 import {
   CompositeSchemaCoercer,
   InputStructureCompact,
@@ -14,8 +14,8 @@ import {
   parsePath,
   serialize,
   stringifyPath
-} from "./chunk-TW72MGM2.js";
-import "./chunk-V4HFPIEN.js";
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 export {
   CompositeSchemaCoercer,
   InputStructureCompact,

package/dist/hono.js

@@ -1,7 +1,7 @@
 import {
   OpenAPIServerHandler,
   OpenAPIServerlessHandler
-} from "./chunk-N7JLIFHD.js";
+} from "./chunk-VFGNQS5W.js";
 import {
   CompositeSchemaCoercer,
   InputStructureCompact,
@@ -14,8 +14,8 @@ import {
   parsePath,
   serialize,
   stringifyPath
-} from "./chunk-TW72MGM2.js";
-import "./chunk-V4HFPIEN.js";
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 export {
   CompositeSchemaCoercer,
   InputStructureCompact,

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   forEachAllContractProcedure,
   forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-V4HFPIEN.js";
+} from "./chunk-Q2LSK6YZ.js";
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -36,7 +36,7 @@ var OpenAPIContentBuilder = class {
 };
 
 // src/openapi-generator.ts
-import { fallbackORPCErrorStatus, fallbackToGlobalConfig as fallbackToGlobalConfig2 } from "@orpc/contract";
+import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
 import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
@@ -44,7 +44,7 @@ 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,8 +52,8 @@ var OpenAPIInputStructureParser = class {
     this.pathParser = pathParser;
   }
   parse(contract, structure) {
-    const inputSchema = this.schemaConverter.convert(contract["~orpc"].InputSchema, { strategy: "input" });
-    const method = fallbackToGlobalConfig("defaultMethod", contract["~orpc"].route?.method);
+    const inputSchema = this.schemaConverter.convert(contract["~orpc"].inputSchema, { strategy: "input" });
+    const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route?.method);
     const httpPath = contract["~orpc"].route?.path;
     if (this.schemaUtils.isAnySchema(inputSchema)) {
       return {
@@ -145,7 +145,7 @@ var OpenAPIOutputStructureParser = class {
     this.schemaUtils = schemaUtils;
   }
   parse(contract, structure) {
-    const outputSchema = this.schemaConverter.convert(contract["~orpc"].OutputSchema, { strategy: "output" });
+    const outputSchema = this.schemaConverter.convert(contract["~orpc"].outputSchema, { strategy: "output" });
     if (this.schemaUtils.isAnySchema(outputSchema)) {
       return {
         headersSchema: void 0,
@@ -412,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, {
@@ -429,14 +429,10 @@ var OpenAPIGenerator = class {
           content: this.contentBuilder.build(bodySchema)
         } : void 0;
         const responses = {};
-        responses[fallbackToGlobalConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
-          description: fallbackToGlobalConfig2("defaultSuccessDescription", def.route?.successDescription),
-          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
+        responses[fallbackContractConfig2("defaultSuccessStatus", def.route?.successStatus)] = {
+          description: fallbackContractConfig2("defaultSuccessDescription", def.route?.successDescription),
+          content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema) : void 0,
+          headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema) : void 0
         };
         const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
           ...config,

package/dist/next.js

@@ -1,7 +1,7 @@
 import {
   OpenAPIServerHandler,
   OpenAPIServerlessHandler
-} from "./chunk-N7JLIFHD.js";
+} from "./chunk-VFGNQS5W.js";
 import {
   CompositeSchemaCoercer,
   InputStructureCompact,
@@ -14,8 +14,8 @@ import {
   parsePath,
   serialize,
   stringifyPath
-} from "./chunk-TW72MGM2.js";
-import "./chunk-V4HFPIEN.js";
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 export {
   CompositeSchemaCoercer,
   InputStructureCompact,

package/dist/node.js

@@ -1,7 +1,7 @@
 import {
   OpenAPIHandler
-} from "./chunk-TW72MGM2.js";
-import "./chunk-V4HFPIEN.js";
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 
 // src/adapters/node/openapi-handler.ts
 import { createRequest, sendResponse } from "@orpc/server/node";

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

@@ -1,4 +1,4 @@
-import type { Context, Router, WithSignal } from '@orpc/server';
+import type { Context, Router } from '@orpc/server';
 import type { FetchHandler, FetchHandleRest, FetchHandleResult } from '@orpc/server/fetch';
 import type { PublicInputStructureCompact } from './input-structure-compact';
 import { type Hooks } from '@orpc/shared';
@@ -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, FetchHandleResult, T, WithSignal> & {
+export type OpenAPIHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, any> & {
     jsonSerializer?: PublicJSONSerializer;
     procedureMatcher?: PublicOpenAPIProcedureMatcher;
     payloadCodec?: PublicOpenAPIPayloadCodec;

package/dist/src/adapters/fetch/openapi-procedure-matcher.d.ts

@@ -1,14 +1,14 @@
+import type { AnyProcedure, AnyRouter } from '@orpc/server';
 import type { Router as BaseHono, Params } from 'hono/router';
-import { type ANY_PROCEDURE, type ANY_ROUTER } from '@orpc/server';
 export type Hono = BaseHono<[string, string[]]>;
 export declare class OpenAPIProcedureMatcher {
     private readonly hono;
     private readonly router;
     private pendingRouters;
-    constructor(hono: Hono, router: ANY_ROUTER);
+    constructor(hono: Hono, router: AnyRouter);
     match(method: string, pathname: string): Promise<{
         path: string[];
-        procedure: ANY_PROCEDURE;
+        procedure: AnyProcedure;
         params: Params;
     } | undefined>;
     private add;

package/dist/src/adapters/fetch/schema-coercer.d.ts

@@ -1,6 +1,6 @@
 import type { Schema } from '@orpc/contract';
 export interface SchemaCoercer {
-    coerce: (schema: Schema, value: unknown) => unknown;
+    coerce(schema: Schema, value: unknown): unknown;
 }
 export declare class CompositeSchemaCoercer implements SchemaCoercer {
     private readonly coercers;

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

@@ -1,4 +1,4 @@
-import type { ANY_ROUTER } from '@orpc/server';
+import type { AnyRouter } 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';
@@ -61,7 +61,7 @@ export declare class OpenAPIGenerator {
     private readonly considerMissingTagDefinitionAsError;
     private readonly strictErrorResponses;
     constructor(options?: OpenAPIGeneratorOptions);
-    generate(router: ContractRouter<any> | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
+    generate(router: ContractRouter<any> | AnyRouter, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
 }
 export {};
 //# sourceMappingURL=openapi-generator.d.ts.map

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

@@ -1,8 +1,8 @@
+import type { AnyContractProcedure } 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';
-import { type ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
 export interface OpenAPIInputStructureParseResult {
     paramsSchema: ObjectSchema | undefined;
     querySchema: ObjectSchema | undefined;
@@ -14,7 +14,7 @@ export declare class OpenAPIInputStructureParser {
     private readonly schemaUtils;
     private readonly pathParser;
     constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils, pathParser: PublicOpenAPIPathParser);
-    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
+    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIInputStructureParseResult;
     private parseDetailedSchema;
     private parseCompactSchema;
 }

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

@@ -1,4 +1,4 @@
-import type { ANY_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { AnyContractProcedure } from '@orpc/contract';
 import type { JSONSchema, ObjectSchema } from './schema';
 import type { SchemaConverter } from './schema-converter';
 import type { PublicSchemaUtils } from './schema-utils';
@@ -10,7 +10,7 @@ export declare class OpenAPIOutputStructureParser {
     private readonly schemaConverter;
     private readonly schemaUtils;
     constructor(schemaConverter: SchemaConverter, schemaUtils: PublicSchemaUtils);
-    parse(contract: ANY_CONTRACT_PROCEDURE, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
+    parse(contract: AnyContractProcedure, structure: 'compact' | 'detailed'): OpenAPIOutputStructureParseResult;
     private parseDetailedSchema;
     private parseCompactSchema;
 }

package/dist/src/schema-converter.d.ts

@@ -4,8 +4,8 @@ export interface SchemaConvertOptions {
     strategy: 'input' | 'output';
 }
 export interface SchemaConverter {
-    condition: (schema: Schema, options: SchemaConvertOptions) => boolean;
-    convert: (schema: Schema, options: SchemaConvertOptions) => JSONSchema.JSONSchema;
+    condition(schema: Schema, options: SchemaConvertOptions): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
 }
 export declare class CompositeSchemaConverter implements SchemaConverter {
     private readonly converters;

package/dist/src/utils.d.ts

@@ -1,18 +1,18 @@
-import type { ContractRouter, HTTPPath, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
-import type { ANY_PROCEDURE, ANY_ROUTER, Lazy } from '@orpc/server';
+import type { AnyContractProcedure, AnyContractRouter, HTTPPath } from '@orpc/contract';
+import type { AnyProcedure, AnyRouter, Lazy } from '@orpc/server';
 export interface EachLeafOptions {
-    router: ContractRouter<any> | ANY_ROUTER;
+    router: AnyContractRouter | AnyRouter;
     path: string[];
 }
 export interface EachLeafCallbackOptions {
-    contract: WELL_CONTRACT_PROCEDURE;
+    contract: AnyContractProcedure;
     path: string[];
 }
 export interface EachContractLeafResultItem {
-    router: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER> | ANY_PROCEDURE>;
+    router: Lazy<AnyProcedure> | Lazy<Record<string, AnyRouter> | AnyProcedure>;
     path: string[];
 }
 export declare function forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
-export declare function forEachAllContractProcedure(router: ContractRouter<any> | ANY_ROUTER, callback: (options: EachLeafCallbackOptions) => void): Promise<void>;
+export declare function forEachAllContractProcedure(router: AnyContractRouter | AnyRouter, 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.f22c7ec",
+  "version": "0.0.0-next.f56d2b3",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -58,9 +58,9 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.f22c7ec",
-    "@orpc/shared": "0.0.0-next.f22c7ec",
-    "@orpc/server": "0.0.0-next.f22c7ec"
+    "@orpc/server": "0.0.0-next.f56d2b3",
+    "@orpc/contract": "0.0.0-next.f56d2b3",
+    "@orpc/shared": "0.0.0-next.f56d2b3"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",