@orpc/openapi 0.0.0-next.ee0aeaf → 0.0.0-next.f99e554

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/adapters/fetch/bracket-notation.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Serialize an object or array into a list of [key, value] pairs.
+ * The key will express by using bracket-notation.
+ *
+ * Notice: This way cannot express the empty object or array.
+ *
+ * @example
+ * ```ts
+ * const payload = {
+ *  name: 'John Doe',
+ *  pets: ['dog', 'cat'],
+ * }
+ *
+ * const entities = serialize(payload)
+ *
+ * expect(entities).toEqual([
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ * ])
+ * ```
+ */
+export declare function serialize(payload: unknown, parentKey?: string): [string, unknown][];
+/**
+ * Deserialize a list of [key, value] pairs into an object or array.
+ * The key is expressed by using bracket-notation.
+ *
+ * @example
+ * ```ts
+ * const entities = [
+ *  ['name', 'John Doe'],
+ *  ['name[pets][0]', 'dog'],
+ *  ['name[pets][1]', 'cat'],
+ *  ['name[dogs][]', 'hello'],
+ *  ['name[dogs][]', 'kitty'],
+ * ]
+ *
+ * const payload = deserialize(entities)
+ *
+ * expect(payload).toEqual({
+ *  name: 'John Doe',
+ *  pets: { 0: 'dog', 1: 'cat' },
+ *  dogs: ['hello', 'kitty'],
+ * })
+ * ```
+ */
+export declare function deserialize(entities: readonly (readonly [string, unknown])[]): Record<string, unknown> | unknown[] | undefined;
+/**
+ * Escape the `[`, `]`, and `\` chars in a path segment.
+ *
+ * @example
+ * ```ts
+ * expect(escapeSegment('name[pets')).toEqual('name\\[pets')
+ * ```
+ */
+export declare function escapeSegment(segment: string): string;
+/**
+ * Convert an array of path segments into a path string using bracket-notation.
+ *
+ * For the special char `[`, `]`, and `\` will be escaped by adding `\` at start.
+ *
+ * @example
+ * ```ts
+ * expect(stringifyPath(['name', 'pets', '0'])).toEqual('name[pets][0]')
+ * ```
+ */
+export declare function stringifyPath(path: readonly [string, ...string[]]): string;
+/**
+ * Convert a path string using bracket-notation into an array of path segments.
+ *
+ * For the special char `[`, `]`, and `\` you should escape by adding `\` at start.
+ * It only treats a pair `[${string}]` as a path segment.
+ * If missing or escape it will bypass and treat as normal string.
+ *
+ * @example
+ * ```ts
+ * expect(parsePath('name[pets][0]')).toEqual(['name', 'pets', '0'])
+ * expect(parsePath('name[pets][0')).toEqual(['name', 'pets', '[0'])
+ * expect(parsePath('name[pets[0]')).toEqual(['name', 'pets[0')
+ * expect(parsePath('name\\[pets][0]')).toEqual(['name[pets]', '0'])
+ * ```
+ */
+export declare function parsePath(path: string): [string, ...string[]];
+//# sourceMappingURL=bracket-notation.d.ts.map

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

@@ -0,0 +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

@@ -0,0 +1,33 @@
+import type { Context, Router, WithSignal } from '@orpc/server';
+import type { ConditionalFetchHandler, FetchOptions } 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, Response, T, WithSignal> & {
+    jsonSerializer?: PublicJSONSerializer;
+    procedureMatcher?: PublicOpenAPIProcedureMatcher;
+    payloadCodec?: PublicOpenAPIPayloadCodec;
+    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 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/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 { 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);
+    match(method: string, pathname: string): Promise<{
+        path: string[];
+        procedure: ANY_PROCEDURE;
+        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/fetch/schema-coercer.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '@orpc/contract';
+export interface SchemaCoercer {
+    coerce: (schema: Schema, value: unknown) => unknown;
+}
+export declare class CompositeSchemaCoercer implements SchemaCoercer {
+    private readonly coercers;
+    constructor(coercers: SchemaCoercer[]);
+    coerce(schema: Schema, value: unknown): unknown;
+}
+//# sourceMappingURL=schema-coercer.d.ts.map

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/index.d.ts

@@ -1,3 +1,12 @@
 /** unnoq */
-export * from './generator';
+export * from './json-serializer';
+export * from './openapi';
+export * from './openapi-content-builder';
+export * from './openapi-generator';
+export * from './openapi-parameters-builder';
+export * from './openapi-path-parser';
+export * from './schema';
+export * from './schema-converter';
+export * from './schema-utils';
+export * from './utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/json-serializer.d.ts

@@ -0,0 +1,5 @@
+export declare class JSONSerializer {
+    serialize(payload: unknown): unknown;
+}
+export type PublicJSONSerializer = Pick<JSONSerializer, keyof JSONSerializer>;
+//# sourceMappingURL=json-serializer.d.ts.map

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

@@ -0,0 +1,10 @@
+import type { OpenAPI } from './openapi';
+import type { JSONSchema } from './schema';
+import type { PublicSchemaUtils } from './schema-utils';
+export declare class OpenAPIContentBuilder {
+    private readonly schemaUtils;
+    constructor(schemaUtils: PublicSchemaUtils);
+    build(jsonSchema: JSONSchema.JSONSchema, options?: Partial<OpenAPI.MediaTypeObject>): OpenAPI.ContentObject;
+}
+export type PublicOpenAPIContentBuilder = Pick<OpenAPIContentBuilder, keyof OpenAPIContentBuilder>;
+//# sourceMappingURL=openapi-content-builder.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

@@ -0,0 +1,60 @@
+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';
+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;
+    schemaConverters?: SchemaConverter[];
+    schemaUtils?: PublicSchemaUtils;
+    jsonSerializer?: PublicJSONSerializer;
+    pathParser?: PublicOpenAPIPathParser;
+    inputStructureParser?: PublicOpenAPIInputStructureParser;
+    outputStructureParser?: PublicOpenAPIOutputStructureParser;
+    /**
+     * Throw error when you missing define tag definition on OpenAPI root tags
+     *
+     * Example: if procedure has tags ['foo', 'bar'], and OpenAPI root tags is ['foo'], then error will be thrown
+     * Because OpenAPI root tags is missing 'bar' tag
+     *
+     * @default false
+     */
+    considerMissingTagDefinitionAsError?: boolean;
+    /**
+     * Weather ignore procedures that has no path defined.
+     *
+     * @default false
+     */
+    ignoreUndefinedPathProcedures?: boolean;
+    /**
+     * What to do when we found an error with our router
+     *
+     * @default 'throw'
+     */
+    errorHandlerStrategy?: ErrorHandlerStrategy;
+}
+export declare class OpenAPIGenerator {
+    private readonly contentBuilder;
+    private readonly parametersBuilder;
+    private readonly schemaConverter;
+    private readonly schemaUtils;
+    private readonly jsonSerializer;
+    private readonly pathParser;
+    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>;
+}
+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

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

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

package/dist/src/openapi-path-parser.d.ts

@@ -0,0 +1,8 @@
+export declare class OpenAPIPathParser {
+    parseDynamicParams(path: string): {
+        name: string;
+        raw: string;
+    }[];
+}
+export type PublicOpenAPIPathParser = Pick<OpenAPIPathParser, keyof OpenAPIPathParser>;
+//# sourceMappingURL=openapi-path-parser.d.ts.map

package/dist/src/openapi.d.ts

@@ -0,0 +1,3 @@
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+export type * as OpenAPI from 'openapi3-ts/oas31';
+//# sourceMappingURL=openapi.d.ts.map

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

@@ -0,0 +1,16 @@
+import type { Schema } from '@orpc/contract';
+import type { JSONSchema } from './schema';
+export interface SchemaConvertOptions {
+    strategy: 'input' | 'output';
+}
+export interface SchemaConverter {
+    condition: (schema: Schema, options: SchemaConvertOptions) => boolean;
+    convert: (schema: Schema, options: SchemaConvertOptions) => JSONSchema.JSONSchema;
+}
+export declare class CompositeSchemaConverter implements SchemaConverter {
+    private readonly converters;
+    constructor(converters: SchemaConverter[]);
+    condition(): boolean;
+    convert(schema: Schema, options: SchemaConvertOptions): JSONSchema.JSONSchema;
+}
+//# sourceMappingURL=schema-converter.d.ts.map

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

@@ -0,0 +1,11 @@
+import { type FileSchema, type JSONSchema, type ObjectSchema } from './schema';
+export declare class SchemaUtils {
+    isFileSchema(schema: JSONSchema.JSONSchema): schema is FileSchema;
+    isObjectSchema(schema: JSONSchema.JSONSchema): schema is ObjectSchema;
+    isAnySchema(schema: JSONSchema.JSONSchema): boolean;
+    isUndefinableSchema(schema: JSONSchema.JSONSchema): boolean;
+    separateObjectSchema(schema: ObjectSchema, separatedProperties: string[]): [matched: ObjectSchema, rest: ObjectSchema];
+    filterSchemaBranches(schema: JSONSchema.JSONSchema, check: (schema: JSONSchema.JSONSchema) => boolean, matches?: JSONSchema.JSONSchema[]): [matches: JSONSchema.JSONSchema[], rest: JSONSchema.JSONSchema | undefined];
+}
+export type PublicSchemaUtils = Pick<SchemaUtils, keyof SchemaUtils>;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/schema.d.ts

@@ -0,0 +1,12 @@
+import * as JSONSchema from 'json-schema-typed/draft-2020-12';
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+export { JSONSchema };
+export type ObjectSchema = JSONSchema.JSONSchema & {
+    type: 'object';
+} & object;
+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")[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/src/utils.d.ts

@@ -1,7 +1,7 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractRouter, HTTPPath, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
-import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Lazy, Router } from '@orpc/server';
+import type { ContractRouter, HTTPPath, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { ANY_PROCEDURE, ANY_ROUTER, Lazy } from '@orpc/server';
 export interface EachLeafOptions {
-    router: ANY_PROCEDURE | Router<any> | ContractRouter | ANY_CONTRACT_PROCEDURE;
+    router: ContractRouter | ANY_ROUTER;
     path: string[];
 }
 export interface EachLeafCallbackOptions {
@@ -9,9 +9,10 @@ export interface EachLeafCallbackOptions {
     path: string[];
 }
 export interface EachContractLeafResultItem {
-    lazy: ANY_LAZY_PROCEDURE | Lazy<Router<any>>;
+    router: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER> | ANY_PROCEDURE>;
     path: string[];
 }
-export declare function eachContractProcedureLeaf(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+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 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.ee0aeaf",
+  "version": "0.0.0-next.f99e554",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -20,10 +20,15 @@
       "default": "./dist/index.js"
     },
     "./fetch": {
-      "types": "./dist/src/fetch/index.d.ts",
+      "types": "./dist/src/adapters/fetch/index.d.ts",
       "import": "./dist/fetch.js",
       "default": "./dist/fetch.js"
     },
+    "./node": {
+      "types": "./dist/src/adapters/node/index.d.ts",
+      "import": "./dist/node.js",
+      "default": "./dist/node.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -34,23 +39,26 @@
     "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",
     "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",
-    "@orpc/contract": "0.0.0-next.ee0aeaf",
-    "@orpc/server": "0.0.0-next.ee0aeaf",
-    "@orpc/transformer": "0.0.0-next.ee0aeaf",
-    "@orpc/zod": "0.0.0-next.ee0aeaf",
-    "@orpc/shared": "0.0.0-next.ee0aeaf"
+    "wildcard-match": "^5.1.3",
+    "@orpc/contract": "0.0.0-next.f99e554",
+    "@orpc/shared": "0.0.0-next.f99e554",
+    "@orpc/server": "0.0.0-next.f99e554"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
-    "hono": "^4.6.12",
     "zod": "^3.24.1"
   },
   "scripts": {
-    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "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:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }