@orpc/openapi 0.0.0-next.141bae5 → 0.0.0-next.1431467

package/dist/{index.js → index.mjs}

@@ -1,16 +1,59 @@
-import {
-  JSONSerializer,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
-  standardizeHTTPPath
-} from "./chunk-KNYXLM77.js";
+import { isProcedure, eachAllContractProcedure } from '@orpc/server';
+import { OpenApiBuilder } from 'openapi3-ts/oas31';
+export { OpenApiBuilder } from 'openapi3-ts/oas31';
+import { findDeepMatches, isObject, get, omit, group } from '@orpc/shared';
+import { fallbackORPCErrorStatus } from '@orpc/client';
+import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
+import { OpenAPIJsonSerializer } from '@orpc/openapi-client/standard';
+export { Format as JSONSchemaFormat, keywords as JSONSchemaKeywords } from 'json-schema-typed/draft-2020-12';
+import { t as toOpenAPI31RoutePattern } from './shared/openapi.BHG_gu5Z.mjs';
+export { s as standardizeHTTPPath } from './shared/openapi.BHG_gu5Z.mjs';
 
-// src/openapi.ts
-import { OpenApiBuilder } from "openapi3-ts/oas31";
+const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
+function setOperationExtender(o, extend) {
+  return new Proxy(o, {
+    get(target, prop, receiver) {
+      if (prop === OPERATION_EXTENDER_SYMBOL) {
+        return extend;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getOperationExtender(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function extendOperation(operation, procedure) {
+  const operationExtenders = [];
+  for (const errorItem of Object.values(procedure["~orpc"].errorMap)) {
+    const maybeExtender = getOperationExtender(errorItem);
+    if (maybeExtender) {
+      operationExtenders.push(maybeExtender);
+    }
+  }
+  if (isProcedure(procedure)) {
+    for (const middleware of procedure["~orpc"].middlewares) {
+      const maybeExtender = getOperationExtender(middleware);
+      if (maybeExtender) {
+        operationExtenders.push(maybeExtender);
+      }
+    }
+  }
+  let currentOperation = operation;
+  for (const extender of operationExtenders) {
+    if (typeof extender === "function") {
+      currentOperation = extender(currentOperation, procedure);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...extender
+      };
+    }
+  }
+  return currentOperation;
+}
 
-// src/openapi-content-builder.ts
-import { findDeepMatches } from "@orpc/shared";
-var OpenAPIContentBuilder = class {
+class OpenAPIContentBuilder {
   constructor(schemaUtils) {
     this.schemaUtils = schemaUtils;
   }
@@ -33,26 +76,20 @@ var OpenAPIContentBuilder = class {
     }
     return content;
   }
-};
+}
 
-// src/openapi-generator.ts
-import { fallbackToGlobalConfig as fallbackToGlobalConfig2 } from "@orpc/contract";
+class OpenAPIError extends Error {
+}
 
-// src/openapi-error.ts
-var OpenAPIError = class extends Error {
-};
-
-// src/openapi-input-structure-parser.ts
-import { fallbackToGlobalConfig } from "@orpc/contract";
-var OpenAPIInputStructureParser = class {
+class OpenAPIInputStructureParser {
   constructor(schemaConverter, schemaUtils, pathParser) {
     this.schemaConverter = schemaConverter;
     this.schemaUtils = schemaUtils;
     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, "input");
+    const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route?.method);
     const httpPath = contract["~orpc"].route?.path;
     if (this.schemaUtils.isAnySchema(inputSchema)) {
       return {
@@ -135,16 +172,15 @@ var OpenAPIInputStructureParser = class {
       bodySchema: method !== "GET" ? rest : void 0
     };
   }
-};
+}
 
-// src/openapi-output-structure-parser.ts
-var OpenAPIOutputStructureParser = class {
+class OpenAPIOutputStructureParser {
   constructor(schemaConverter, schemaUtils) {
     this.schemaConverter = schemaConverter;
     this.schemaUtils = schemaUtils;
   }
   parse(contract, structure) {
-    const outputSchema = this.schemaConverter.convert(contract["~orpc"].OutputSchema, { strategy: "output" });
+    const [_, outputSchema] = this.schemaConverter.convert(contract["~orpc"].outputSchema, "output");
     if (this.schemaUtils.isAnySchema(outputSchema)) {
       return {
         headersSchema: void 0,
@@ -180,17 +216,15 @@ var OpenAPIOutputStructureParser = class {
       bodySchema: outputSchema
     };
   }
-};
+}
 
-// src/openapi-parameters-builder.ts
-import { get, isPlainObject, omit } from "@orpc/shared";
-var OpenAPIParametersBuilder = class {
+class OpenAPIParametersBuilder {
   build(paramIn, jsonSchema, options) {
     const parameters = [];
     for (const name in jsonSchema.properties) {
       const schema = jsonSchema.properties[name];
       const paramExamples = jsonSchema.examples?.filter((example) => {
-        return isPlainObject(example) && name in example;
+        return isObject(example) && name in example;
       }).map((example) => {
         return example[name];
       });
@@ -218,10 +252,9 @@ var OpenAPIParametersBuilder = class {
     }
     return headersObject;
   }
-};
+}
 
-// src/openapi-path-parser.ts
-var OpenAPIPathParser = class {
+class OpenAPIPathParser {
   parseDynamicParams(path) {
     const raws = path.match(/\{([^}]+)\}/g) ?? [];
     return raws.map((raw) => {
@@ -229,34 +262,24 @@ var OpenAPIPathParser = class {
       return { name, raw };
     });
   }
-};
+}
 
-// src/schema-converter.ts
-var CompositeSchemaConverter = class {
+class CompositeSchemaConverter {
   converters;
   constructor(converters) {
     this.converters = converters;
   }
-  condition() {
-    return true;
-  }
-  convert(schema, options) {
+  convert(schema, strategy) {
     for (const converter of this.converters) {
-      if (converter.condition(schema, options)) {
-        return converter.convert(schema, options);
+      if (converter.condition(schema, strategy)) {
+        return converter.convert(schema, strategy);
       }
     }
-    return {};
+    return [false, {}];
   }
-};
+}
 
-// src/schema-utils.ts
-import { isPlainObject as isPlainObject2 } from "@orpc/shared";
-
-// src/schema.ts
-import * as JSONSchema from "json-schema-typed/draft-2020-12";
-import { Format } from "json-schema-typed/draft-2020-12";
-var NON_LOGIC_KEYWORDS = [
+const NON_LOGIC_KEYWORDS = [
   // Core Documentation Keywords
   "$anchor",
   "$comment",
@@ -284,23 +307,22 @@ var NON_LOGIC_KEYWORDS = [
   "$dynamicRef"
 ];
 
-// src/schema-utils.ts
-var SchemaUtils = class {
+class SchemaUtils {
   isFileSchema(schema) {
-    return typeof schema === "object" && schema.type === "string" && typeof schema.contentMediaType === "string";
+    return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
   }
   isObjectSchema(schema) {
-    return typeof schema === "object" && schema.type === "object";
+    return isObject(schema) && schema.type === "object";
   }
   isAnySchema(schema) {
-    return schema === true || Object.keys(schema).length === 0;
+    return schema === true || Object.keys(schema).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
   }
   isUndefinableSchema(schema) {
     const [matches] = this.filterSchemaBranches(schema, (schema2) => {
       if (typeof schema2 === "boolean") {
         return schema2;
       }
-      return Object.keys(schema2).length === 0;
+      return Object.keys(schema2).filter((key) => !NON_LOGIC_KEYWORDS.includes(key)).length === 0;
     });
     return matches.length > 0;
   }
@@ -313,7 +335,7 @@ var SchemaUtils = class {
     }, {});
     matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
     matched.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
+      if (!isObject(example)) {
         return example;
       }
       return Object.entries(example).reduce((acc, [key, value]) => {
@@ -329,7 +351,7 @@ var SchemaUtils = class {
     }, {});
     rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
     rest.examples = schema.examples?.map((example) => {
-      if (!isPlainObject2(example)) {
+      if (!isObject(example)) {
         return example;
       }
       return Object.entries(example).reduce((acc, [key, value]) => {
@@ -369,10 +391,9 @@ var SchemaUtils = class {
     }
     return [matches, schema];
   }
-};
+}
 
-// src/openapi-generator.ts
-var OpenAPIGenerator = class {
+class OpenAPIGenerator {
   contentBuilder;
   parametersBuilder;
   schemaConverter;
@@ -384,11 +405,12 @@ var OpenAPIGenerator = class {
   errorHandlerStrategy;
   ignoreUndefinedPathProcedures;
   considerMissingTagDefinitionAsError;
+  strictErrorResponses;
   constructor(options) {
     this.parametersBuilder = options?.parametersBuilder ?? new OpenAPIParametersBuilder();
     this.schemaConverter = new CompositeSchemaConverter(options?.schemaConverters ?? []);
     this.schemaUtils = options?.schemaUtils ?? new SchemaUtils();
-    this.jsonSerializer = options?.jsonSerializer ?? new JSONSerializer();
+    this.jsonSerializer = options?.jsonSerializer ?? new OpenAPIJsonSerializer();
     this.contentBuilder = options?.contentBuilder ?? new OpenAPIContentBuilder(this.schemaUtils);
     this.pathParser = new OpenAPIPathParser();
     this.inputStructureParser = options?.inputStructureParser ?? new OpenAPIInputStructureParser(this.schemaConverter, this.schemaUtils, this.pathParser);
@@ -396,6 +418,7 @@ var OpenAPIGenerator = class {
     this.errorHandlerStrategy = options?.errorHandlerStrategy ?? "throw";
     this.ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
     this.considerMissingTagDefinitionAsError = options?.considerMissingTagDefinitionAsError ?? false;
+    this.strictErrorResponses = options?.strictErrorResponses ?? true;
   }
   async generate(router, doc) {
     const builder = new OpenApiBuilder({
@@ -403,37 +426,186 @@ var OpenAPIGenerator = class {
       openapi: "3.1.1"
     });
     const rootTags = doc.tags?.map((tag) => tag.name) ?? [];
-    await forEachAllContractProcedure(router, ({ contract, path }) => {
+    await eachAllContractProcedure({
+      path: [],
+      router
+    }, ({ contract, path }) => {
       try {
         const def = contract["~orpc"];
         if (this.ignoreUndefinedPathProcedures && def.route?.path === void 0) {
           return;
         }
-        const method = fallbackToGlobalConfig2("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 { 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, {
-          required: true
-        }) : [];
-        const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
-        const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
-        const parameters = [...params, ...query, ...headers];
-        const requestBody = bodySchema !== void 0 ? {
-          required: this.schemaUtils.isUndefinableSchema(bodySchema),
-          content: this.contentBuilder.build(bodySchema)
-        } : void 0;
-        const successResponse = {
-          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
-        };
+        const method = fallbackContractConfig("defaultMethod", def.route?.method);
+        const httpPath = def.route?.path ? toOpenAPI31RoutePattern(def.route?.path) : `/${path.map(encodeURIComponent).join("/")}`;
+        const { parameters, requestBody } = (() => {
+          const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.inputSchema);
+          if (eventIteratorSchemaDetails) {
+            const requestBody3 = {
+              required: true,
+              content: {
+                "text/event-stream": {
+                  schema: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "message" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.yields, "input")[1],
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "done" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.returns, "input")[1],
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "error" },
+                          data: {},
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      }
+                    ]
+                  }
+                }
+              }
+            };
+            return { requestBody: requestBody3, parameters: [] };
+          }
+          const inputStructure = fallbackContractConfig("defaultInputStructure", def.route?.inputStructure);
+          const { paramsSchema, querySchema, headersSchema, bodySchema } = this.inputStructureParser.parse(contract, inputStructure);
+          const params = paramsSchema ? this.parametersBuilder.build("path", paramsSchema, {
+            required: true
+          }) : [];
+          const query = querySchema ? this.parametersBuilder.build("query", querySchema) : [];
+          const headers = headersSchema ? this.parametersBuilder.build("header", headersSchema) : [];
+          const parameters2 = [...params, ...query, ...headers];
+          const requestBody2 = bodySchema !== void 0 ? {
+            required: this.schemaUtils.isUndefinableSchema(bodySchema),
+            content: this.contentBuilder.build(bodySchema)
+          } : void 0;
+          return { parameters: parameters2, requestBody: requestBody2 };
+        })();
+        const { responses } = (() => {
+          const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(def.outputSchema);
+          if (eventIteratorSchemaDetails) {
+            const responses3 = {};
+            responses3[fallbackContractConfig("defaultSuccessStatus", def.route?.successStatus)] = {
+              description: fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription),
+              content: {
+                "text/event-stream": {
+                  schema: {
+                    oneOf: [
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "message" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.yields, "input")[1],
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "done" },
+                          data: this.schemaConverter.convert(eventIteratorSchemaDetails.returns, "input")[1],
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      },
+                      {
+                        type: "object",
+                        properties: {
+                          event: { type: "string", const: "error" },
+                          data: {},
+                          id: { type: "string" },
+                          retry: { type: "number" }
+                        },
+                        required: ["event", "data"]
+                      }
+                    ]
+                  }
+                }
+              }
+            };
+            return { responses: responses3 };
+          }
+          const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route?.outputStructure);
+          const { headersSchema: resHeadersSchema, bodySchema: resBodySchema } = this.outputStructureParser.parse(contract, outputStructure);
+          const responses2 = {};
+          responses2[fallbackContractConfig("defaultSuccessStatus", def.route?.successStatus)] = {
+            description: fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription),
+            content: resBodySchema !== void 0 ? this.contentBuilder.build(resBodySchema) : void 0,
+            headers: resHeadersSchema !== void 0 ? this.parametersBuilder.buildHeadersObject(resHeadersSchema) : void 0
+          };
+          return { responses: responses2 };
+        })();
+        const errors = group(Object.entries(def.errorMap ?? {}).filter(([_, config]) => config).map(([code, config]) => ({
+          ...config,
+          code,
+          status: fallbackORPCErrorStatus(code, config?.status)
+        })), (error) => error.status);
+        for (const status in errors) {
+          const configs = errors[status];
+          if (!configs || configs.length === 0) {
+            continue;
+          }
+          const schemas = configs.map(({ data, code, message }) => {
+            const json = {
+              type: "object",
+              properties: {
+                defined: { const: true },
+                code: { const: code },
+                status: { const: Number(status) },
+                message: { type: "string", default: message },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            };
+            if (data) {
+              const dataJson = this.schemaConverter.convert(data, "output")[1];
+              json.properties.data = dataJson;
+              if (!this.schemaUtils.isUndefinableSchema(dataJson)) {
+                json.required.push("data");
+              }
+            }
+            return json;
+          });
+          if (this.strictErrorResponses) {
+            schemas.push({
+              type: "object",
+              properties: {
+                defined: { const: false },
+                code: { type: "string" },
+                status: { type: "number" },
+                message: { type: "string" },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            });
+          }
+          const contentSchema = schemas.length === 1 ? schemas[0] : {
+            oneOf: schemas
+          };
+          responses[status] = {
+            description: status,
+            content: this.contentBuilder.build(contentSchema)
+          };
+        }
         if (this.considerMissingTagDefinitionAsError && def.route?.tags) {
           const missingTag = def.route?.tags.find((tag) => !rootTags.includes(tag));
           if (missingTag !== void 0) {
@@ -450,12 +622,11 @@ var OpenAPIGenerator = class {
           operationId: path.join("."),
           parameters: parameters.length ? parameters : void 0,
           requestBody,
-          responses: {
-            [fallbackToGlobalConfig2("defaultSuccessStatus", def.route?.successStatus)]: successResponse
-          }
+          responses
         };
+        const extendedOperation = extendOperation(operation, contract);
         builder.addPath(httpPath, {
-          [method.toLocaleLowerCase()]: operation
+          [method.toLocaleLowerCase()]: extendedOperation
         });
       } catch (e) {
         if (e instanceof OpenAPIError) {
@@ -474,23 +645,12 @@ var OpenAPIGenerator = class {
         }
       }
     });
-    return this.jsonSerializer.serialize(builder.getSpec());
+    return this.jsonSerializer.serialize(builder.getSpec())[0];
   }
+}
+
+const oo = {
+  spec: setOperationExtender
 };
-export {
-  CompositeSchemaConverter,
-  JSONSchema,
-  Format as JSONSchemaFormat,
-  JSONSerializer,
-  NON_LOGIC_KEYWORDS,
-  OpenAPIContentBuilder,
-  OpenAPIGenerator,
-  OpenAPIParametersBuilder,
-  OpenAPIPathParser,
-  OpenApiBuilder,
-  SchemaUtils,
-  forEachAllContractProcedure,
-  forEachContractProcedure,
-  standardizeHTTPPath
-};
-//# sourceMappingURL=index.js.map
+
+export { CompositeSchemaConverter, NON_LOGIC_KEYWORDS, OpenAPIContentBuilder, OpenAPIGenerator, OpenAPIParametersBuilder, OpenAPIPathParser, SchemaUtils, extendOperation, getOperationExtender, oo, setOperationExtender, toOpenAPI31RoutePattern };

package/dist/shared/openapi.B6uueFtN.mjs

@@ -0,0 +1,29 @@
+import { OpenAPISerializer } from '@orpc/openapi-client/standard';
+import { StandardHandler } from '@orpc/server/standard';
+import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
+import { a as OpenAPIMatcher, O as OpenAPICodec } from './openapi.C_biOx82.mjs';
+
+class OpenAPIHandler {
+  standardHandler;
+  constructor(router, options = {}) {
+    const serializer = new OpenAPISerializer();
+    const matcher = new OpenAPIMatcher();
+    const codec = new OpenAPICodec(serializer);
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(request, ...[
+    options = {}
+  ]) {
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, options)
+    };
+  }
+}
+
+export { OpenAPIHandler as O };

package/dist/shared/openapi.BHG_gu5Z.mjs

@@ -0,0 +1,8 @@
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function toOpenAPI31RoutePattern(path) {
+  return standardizeHTTPPath(path).replace(/\{\+([^}]+)\}/g, "{$1}");
+}
+
+export { standardizeHTTPPath as s, toOpenAPI31RoutePattern as t };