@orpc/openapi 0.23.0 → 0.24.0

package/dist/index.js

@@ -369,8 +369,18 @@ var SchemaUtils = class {
 
 // src/openapi-generator.ts
 var OpenAPIGenerator = class {
+  contentBuilder;
+  parametersBuilder;
+  schemaConverter;
+  schemaUtils;
+  jsonSerializer;
+  pathParser;
+  inputStructureParser;
+  outputStructureParser;
+  errorHandlerStrategy;
+  ignoreUndefinedPathProcedures;
+  considerMissingTagDefinitionAsError;
   constructor(options) {
-    this.options = options;
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
     this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
@@ -379,15 +389,10 @@ var OpenAPIGenerator = class {
     this.pathParser = new OpenAPIPathParser();
     this.inputStructureParser = options?.inputStructureParser ?? new OpenAPIInputStructureParser(this.schemaConverter, this.schemaUtils, this.pathParser);
     this.outputStructureParser = options?.outputStructureParser ?? new OpenAPIOutputStructureParser(this.schemaConverter, this.schemaUtils);
+    this.errorHandlerStrategy = options?.errorHandlerStrategy ?? "throw";
+    this.ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
+    this.considerMissingTagDefinitionAsError = options?.considerMissingTagDefinitionAsError ?? false;
   }
-  contentBuilder;
-  parametersBuilder;
-  schemaConverter;
-  schemaUtils;
-  jsonSerializer;
-  pathParser;
-  inputStructureParser;
-  outputStructureParser;
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
       ...doc,
@@ -397,7 +402,7 @@ var OpenAPIGenerator = class {
     await forEachAllContractProcedure(router, ({ contract, path }) => {
       try {
         const def = contract["~orpc"];
-        if (this.options?.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
+        if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
           return;
         }
         const method = def.route?.method ?? "POST";
@@ -423,7 +428,7 @@ var OpenAPIGenerator = class {
             example: def.outputExample
           }) : void 0
         };
-        if (this.options?.considerMissingTagDefinitionAsError && def.route?.tags) {
+        if (this.considerMissingTagDefinitionAsError && def.route?.tags) {
           const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
           if (missingTag !== void 0) {
             throw new OpenAPIError(
@@ -452,10 +457,14 @@ var OpenAPIGenerator = class {
             Generate OpenAPI Error: ${e.message}
             Happened at path: ${path.join(".")}
           `, { cause: e });
-          if (this.options?.throwOnError) {
+          if (this.errorHandlerStrategy === "throw") {
             throw error;
           }
-          console.error(error);
+          if (this.errorHandlerStrategy === "log") {
+            console.error(error);
+          }
+        } else {
+          throw e;
         }
       }
     });

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/{fetch → adapters/fetch}/openapi-handler.d.ts

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

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

@@ -1,4 +1,4 @@
-import type { PublicJSONSerializer } from '../json-serializer';
+import type { PublicJSONSerializer } from '../../json-serializer';
 export declare class OpenAPIPayloadCodec {
     private readonly jsonSerializer;
     constructor(jsonSerializer: PublicJSONSerializer);

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

@@ -9,6 +9,7 @@ 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;
@@ -34,14 +35,13 @@ 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'
      */
-    throwOnError?: boolean;
+    errorHandlerStrategy?: ErrorHandlerStrategy;
 }
 export declare class OpenAPIGenerator {
-    private readonly options?;
     private readonly contentBuilder;
     private readonly parametersBuilder;
     private readonly schemaConverter;
@@ -50,7 +50,11 @@ export declare class OpenAPIGenerator {
     private readonly pathParser;
     private readonly inputStructureParser;
     private readonly outputStructureParser;
-    constructor(options?: OpenAPIGeneratorOptions | undefined);
+    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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "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,6 +39,7 @@
     "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",
@@ -43,16 +49,16 @@
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
     "wildcard-match": "^5.1.3",
-    "@orpc/contract": "0.23.0",
-    "@orpc/shared": "0.23.0",
-    "@orpc/server": "0.23.0"
+    "@orpc/contract": "0.24.0",
+    "@orpc/server": "0.24.0",
+    "@orpc/shared": "0.24.0"
   },
   "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 --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"
   }