@orpc/openapi 0.0.0-next.31590a1 → 0.0.0-next.32cb70c

package/dist/hono.js

@@ -1,9 +1,34 @@
 import {
-  OpenAPIHandler
-} from "./chunk-HQ34JZI7.js";
-import "./chunk-M5HOHBLW.js";
-import "./chunk-BHJYKXQL.js";
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-VFGNQS5W.js";
+import {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 export {
-  OpenAPIHandler
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
 };
 //# sourceMappingURL=hono.js.map

package/dist/index.js

@@ -1,7 +1,9 @@
 import {
   JSONSerializer,
+  forEachAllContractProcedure,
+  forEachContractProcedure,
   standardizeHTTPPath
-} from "./chunk-BHJYKXQL.js";
+} from "./chunk-Q2LSK6YZ.js";
 
 // src/openapi.ts
 import { OpenApiBuilder } from "openapi3-ts/oas31";
@@ -35,7 +37,6 @@ var OpenAPIContentBuilder = class {
 
 // src/openapi-generator.ts
 import { fallbackContractConfig as fallbackContractConfig2, fallbackORPCErrorStatus } from "@orpc/contract";
-import { eachAllContractProcedure } from "@orpc/server";
 import { group } from "@orpc/shared";
 
 // src/openapi-error.ts
@@ -405,10 +406,7 @@ var OpenAPIGenerator = class {
       openapi: "3.1.1"
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
-    await eachAllContractProcedure({
-      path: [],
-      router
-    }, ({ contract, path }) => {
+    await forEachAllContractProcedure(router, ({ contract, path }) => {
       try {
         const def = contract["~orpc"];
         if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
@@ -541,6 +539,8 @@ export {
   OpenAPIPathParser,
   OpenApiBuilder,
   SchemaUtils,
+  forEachAllContractProcedure,
+  forEachContractProcedure,
   standardizeHTTPPath
 };
 //# sourceMappingURL=index.js.map

package/dist/next.js

@@ -1,9 +1,34 @@
 import {
-  OpenAPIHandler
-} from "./chunk-HQ34JZI7.js";
-import "./chunk-M5HOHBLW.js";
-import "./chunk-BHJYKXQL.js";
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
+} from "./chunk-VFGNQS5W.js";
+import {
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 export {
-  OpenAPIHandler
+  CompositeSchemaCoercer,
+  InputStructureCompact,
+  InputStructureDetailed,
+  OpenAPIHandler,
+  OpenAPIPayloadCodec,
+  OpenAPIProcedureMatcher,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler,
+  deserialize,
+  escapeSegment,
+  parsePath,
+  serialize,
+  stringifyPath
 };
 //# sourceMappingURL=next.js.map

package/dist/node.js

@@ -1,30 +1,46 @@
 import {
-  OpenAPICodec,
-  OpenAPIMatcher
-} from "./chunk-M5HOHBLW.js";
-import "./chunk-BHJYKXQL.js";
+  OpenAPIHandler
+} from "./chunk-SOVQ5ARD.js";
+import "./chunk-Q2LSK6YZ.js";
 
 // src/adapters/node/openapi-handler.ts
-import { nodeHttpResponseSendStandardResponse, nodeHttpToStandardRequest } from "@orpc/server/node";
-import { StandardHandler } from "@orpc/server/standard";
-var OpenAPIHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const matcher = options?.matcher ?? new OpenAPIMatcher(options);
-    const codec = options?.codec ?? new OpenAPICodec(options);
-    this.standardHandler = new StandardHandler(router, matcher, codec, { ...options });
+import { createRequest, sendResponse } from "@orpc/server/node";
+var OpenAPIHandler2 = class {
+  openapiFetchHandler;
+  constructor(hono, router, options) {
+    this.openapiFetchHandler = new OpenAPIHandler(hono, router, options);
   }
-  async handle(req, res, ...rest) {
-    const standardRequest = nodeHttpToStandardRequest(req, res);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
+  async handle(req, res, ...[options]) {
+    const request = createRequest(req, res);
+    const castedOptions = options ?? {};
+    const result = await this.openapiFetchHandler.handle(request, castedOptions);
+    if (result.matched === false) {
       return { matched: false };
     }
-    await nodeHttpResponseSendStandardResponse(res, result.response);
+    await options?.beforeSend?.(result.response, castedOptions.context);
+    await sendResponse(res, result.response);
     return { matched: true };
   }
 };
+
+// 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 {
-  OpenAPIHandler
+  OpenAPIHandler2 as OpenAPIHandler,
+  OpenAPIServerHandler,
+  OpenAPIServerlessHandler
 };
 //# sourceMappingURL=node.js.map

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

@@ -1,2 +1,10 @@
+export * from './bracket-notation';
+export * from './input-structure-compact';
+export * from './input-structure-detailed';
 export * from './openapi-handler';
+export * from './openapi-handler-server';
+export * from './openapi-handler-serverless';
+export * from './openapi-payload-codec';
+export * from './openapi-procedure-matcher';
+export * from './schema-coercer';
 //# sourceMappingURL=index.d.ts.map

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/adapters/fetch/input-structure-detailed.d.ts

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

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

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from './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/fetch/openapi-handler-serverless.d.ts

@@ -0,0 +1,7 @@
+import type { Context, Router } from '@orpc/server';
+import type { OpenAPIHandlerOptions } from './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/fetch/openapi-handler.d.ts

@@ -1,10 +1,32 @@
 import type { Context, Router } from '@orpc/server';
-import type { FetchHandler, FetchHandleResult } from '@orpc/server/fetch';
-import type { StandardHandleRest } from '@orpc/server/standard';
-import type { OpenAPIHandlerOptions } from '../standard';
+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';
+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, any> & {
+    jsonSerializer?: PublicJSONSerializer;
+    procedureMatcher?: PublicOpenAPIProcedureMatcher;
+    payloadCodec?: PublicOpenAPIPayloadCodec;
+    inputBuilderSimple?: PublicInputStructureCompact;
+    inputBuilderFull?: PublicInputStructureDetailed;
+    schemaCoercers?: SchemaCoercer[];
+};
 export declare class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+    private readonly options?;
+    private readonly procedureMatcher;
+    private readonly payloadCodec;
+    private readonly inputStructureCompact;
+    private readonly inputStructureDetailed;
+    private readonly compositeSchemaCoercer;
+    constructor(hono: Hono, router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>> | undefined);
+    handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
+    private decodeInput;
+    private encodeOutput;
+    private assertDetailedOutput;
+    private convertToORPCError;
 }
 //# sourceMappingURL=openapi-handler.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { PublicJSONSerializer } from '../../json-serializer';
+export declare class OpenAPIPayloadCodec {
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: PublicJSONSerializer);
+    encode(payload: unknown, accept: string | undefined): {
+        body: FormData | Blob | string | undefined;
+        headers?: Headers;
+    };
+    private encodeAsJSON;
+    private encodeAsFormData;
+    private encodeAsURLSearchParams;
+    decode(re: Request | Response | Headers | URLSearchParams | FormData): Promise<unknown>;
+}
+export type PublicOpenAPIPayloadCodec = Pick<OpenAPIPayloadCodec, keyof OpenAPIPayloadCodec>;
+//# sourceMappingURL=openapi-payload-codec.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { AnyProcedure, AnyRouter } from '@orpc/server';
+import type { Router as BaseHono, Params } from 'hono/router';
+export type Hono = BaseHono<[string, string[]]>;
+export declare class OpenAPIProcedureMatcher {
+    private readonly hono;
+    private readonly router;
+    private pendingRouters;
+    constructor(hono: Hono, router: AnyRouter);
+    match(method: string, pathname: string): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+        params: Params;
+    } | undefined>;
+    private add;
+    private handlePendingRouters;
+    private convertOpenAPIPathToRouterPath;
+}
+export type PublicOpenAPIProcedureMatcher = Pick<OpenAPIProcedureMatcher, keyof OpenAPIProcedureMatcher>;
+//# sourceMappingURL=openapi-procedure-matcher.d.ts.map

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

@@ -1,2 +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

@@ -1,10 +1,11 @@
 import type { Context, Router } from '@orpc/server';
-import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from '@orpc/server/node';
-import type { StandardHandleRest } from '@orpc/server/standard';
-import type { OpenAPIHandlerOptions } from '../standard';
-export declare class OpenAPIHandler<T extends Context> implements NodeHttpHandler<T> {
-    private readonly standardHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<OpenAPIHandlerOptions<T>>);
-    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { OpenAPIHandlerOptions } from '../fetch/openapi-handler';
+import type { Hono } from '../fetch/openapi-procedure-matcher';
+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>>);
+    handle(req: IncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
 }
 //# 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-generator.d.ts

@@ -1,9 +1,9 @@
+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';
 import type { SchemaConverter } from './schema-converter';
 import { type ContractRouter } from '@orpc/contract';
-import { type AnyRouter } from '@orpc/server';
 import { type PublicJSONSerializer } from './json-serializer';
 import { type OpenAPI } from './openapi';
 import { type PublicOpenAPIContentBuilder } from './openapi-content-builder';

package/dist/src/utils.d.ts

@@ -1,3 +1,18 @@
-import type { HTTPPath } from '@orpc/contract';
+import type { AnyContractProcedure, AnyContractRouter, HTTPPath } from '@orpc/contract';
+import type { AnyProcedure, AnyRouter, Lazy } from '@orpc/server';
+export interface EachLeafOptions {
+    router: AnyContractRouter | AnyRouter;
+    path: string[];
+}
+export interface EachLeafCallbackOptions {
+    contract: AnyContractProcedure;
+    path: string[];
+}
+export interface EachContractLeafResultItem {
+    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: 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.31590a1",
+  "version": "0.0.0-next.32cb70c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,11 +19,6 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
-    "./standard": {
-      "types": "./dist/src/adapters/standard/index.d.ts",
-      "import": "./dist/standard.js",
-      "default": "./dist/standard.js"
-    },
     "./fetch": {
       "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
@@ -59,13 +54,13 @@
     "content-disposition": "^0.5.4",
     "escape-string-regexp": "^5.0.0",
     "fast-content-type-parse": "^2.0.0",
+    "hono": "^4.6.12",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "rou3": "^0.5.1",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.31590a1",
-    "@orpc/shared": "0.0.0-next.31590a1",
-    "@orpc/server": "0.0.0-next.31590a1"
+    "@orpc/contract": "0.0.0-next.32cb70c",
+    "@orpc/server": "0.0.0-next.32cb70c",
+    "@orpc/shared": "0.0.0-next.32cb70c"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",

package/dist/chunk-BHJYKXQL.js

@@ -1,52 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/json-serializer.ts
-import { isPlainObject } from "@orpc/shared";
-var JSONSerializer = class {
-  serialize(payload) {
-    if (payload instanceof Set)
-      return this.serialize([...payload]);
-    if (payload instanceof Map)
-      return this.serialize([...payload.entries()]);
-    if (Array.isArray(payload)) {
-      return payload.map((v) => v === void 0 ? "undefined" : this.serialize(v));
-    }
-    if (Number.isNaN(payload))
-      return "NaN";
-    if (typeof payload === "bigint")
-      return payload.toString();
-    if (payload instanceof Date && Number.isNaN(payload.getTime())) {
-      return "Invalid Date";
-    }
-    if (payload instanceof RegExp)
-      return payload.toString();
-    if (payload instanceof URL)
-      return payload.toString();
-    if (!isPlainObject(payload))
-      return payload;
-    return Object.keys(payload).reduce(
-      (carry, key) => {
-        const val = payload[key];
-        carry[key] = this.serialize(val);
-        return carry;
-      },
-      {}
-    );
-  }
-};
-
-// src/utils.ts
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-
-export {
-  __export,
-  JSONSerializer,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=chunk-BHJYKXQL.js.map

package/dist/chunk-HQ34JZI7.js

@@ -1,32 +0,0 @@
-import {
-  OpenAPICodec,
-  OpenAPIMatcher
-} from "./chunk-M5HOHBLW.js";
-
-// src/adapters/fetch/openapi-handler.ts
-import { fetchRequestToStandardRequest, standardResponseToFetchResponse } from "@orpc/server/fetch";
-import { StandardHandler } from "@orpc/server/standard";
-var OpenAPIHandler = class {
-  standardHandler;
-  constructor(router, options) {
-    const matcher = options?.matcher ?? new OpenAPIMatcher(options);
-    const codec = options?.codec ?? new OpenAPICodec(options);
-    this.standardHandler = new StandardHandler(router, matcher, codec, options);
-  }
-  async handle(request, ...rest) {
-    const standardRequest = fetchRequestToStandardRequest(request);
-    const result = await this.standardHandler.handle(standardRequest, ...rest);
-    if (!result.matched) {
-      return result;
-    }
-    return {
-      matched: true,
-      response: standardResponseToFetchResponse(result.response)
-    };
-  }
-};
-
-export {
-  OpenAPIHandler
-};
-//# sourceMappingURL=chunk-HQ34JZI7.js.map