@orpc/openapi 0.0.0-next.eb37cbe → 0.0.0-next.ed15210

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

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

@@ -0,0 +1,3 @@
+export declare class OpenAPIError extends Error {
+}
+//# sourceMappingURL=openapi-error.d.ts.map

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

@@ -1,12 +1,15 @@
-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 ContractRouter } from '@orpc/contract';
 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;
@@ -14,6 +17,8 @@ export interface OpenAPIGeneratorOptions {
     schemaUtils?: PublicSchemaUtils;
     jsonSerializer?: PublicJSONSerializer;
     pathParser?: PublicOpenAPIPathParser;
+    inputStructureParser?: PublicOpenAPIInputStructureParser;
+    outputStructureParser?: PublicOpenAPIOutputStructureParser;
     /**
      * Throw error when you missing define tag definition on OpenAPI root tags
      *
@@ -30,22 +35,33 @@ export interface OpenAPIGeneratorOptions {
      */
     ignoreUndefinedPathProcedures?: boolean;
     /**
-     * Throw error when you have error in OpenAPI generator
+     * What to do when we found an error with our router
      *
-     * @default false
+     * @default 'throw'
+     */
+    errorHandlerStrategy?: ErrorHandlerStrategy;
+    /**
+     * Strict error response
+     *
+     * @default true
      */
-    throwOnError?: boolean;
+    strictErrorResponses?: boolean;
 }
 export declare class OpenAPIGenerator {
-    private readonly options?;
     private readonly contentBuilder;
     private readonly parametersBuilder;
     private readonly schemaConverter;
     private readonly schemaUtils;
     private readonly jsonSerializer;
     private readonly pathParser;
-    constructor(options?: OpenAPIGeneratorOptions | undefined);
-    generate(router: ContractRouter | ANY_ROUTER, doc: Omit<OpenAPI.OpenAPIObject, 'openapi'>): Promise<OpenAPI.OpenAPIObject>;
-    private handleError;
+    private readonly inputStructureParser;
+    private readonly outputStructureParser;
+    private readonly errorHandlerStrategy;
+    private readonly ignoreUndefinedPathProcedures;
+    private readonly considerMissingTagDefinitionAsError;
+    private readonly strictErrorResponses;
+    constructor(options?: OpenAPIGeneratorOptions);
+    generate(router: ContractRouter<any> | 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 { 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;
+    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

@@ -4,6 +4,9 @@ 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/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 {
@@ -12,7 +12,7 @@ export interface EachContractLeafResultItem {
     router: Lazy<ANY_PROCEDURE> | Lazy<Record<string, ANY_ROUTER> | ANY_PROCEDURE>;
     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 forEachContractProcedure(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[]): EachContractLeafResultItem[];
+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.eb37cbe",
+  "version": "0.0.0-next.ed15210",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -20,10 +20,25 @@
       "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"
     },
+    "./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",
+      "default": "./dist/node.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
@@ -43,16 +58,16 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.0.0-next.eb37cbe",
-    "@orpc/server": "0.0.0-next.eb37cbe",
-    "@orpc/shared": "0.0.0-next.eb37cbe"
+    "@orpc/contract": "0.0.0-next.ed15210",
+    "@orpc/shared": "0.0.0-next.ed15210",
+    "@orpc/server": "0.0.0-next.ed15210"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
     "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 --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }

package/dist/src/fetch/input-builder-simple.d.ts

@@ -1,6 +0,0 @@
-import type { Params } from 'hono/router';
-export declare class InputBuilderSimple {
-    build(params: Params, payload: unknown): unknown;
-}
-export type PublicInputBuilderSimple = Pick<InputBuilderSimple, keyof InputBuilderSimple>;
-//# sourceMappingURL=input-builder-simple.d.ts.map