@orpc/openapi 0.0.0-next.e385fb7 → 0.0.0-next.e49bee7

package/dist/shared/{openapi.ExRBHuvW.mjs → openapi.CzHcOMxv.mjs}

@@ -3,8 +3,8 @@ import { toHttpPath } from '@orpc/client/standard';
 import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
 import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, getDynamicParams } from '@orpc/openapi-client/standard';
 import { isProcedure, resolveContractProcedures } from '@orpc/server';
-import { isObject, stringifyJSON, findDeepMatches, toArray, clone } from '@orpc/shared';
-import { TypeName } from 'json-schema-typed/draft-2020-12';
+import { isObject, stringifyJSON, findDeepMatches, toArray, clone, value } from '@orpc/shared';
+import { TypeName } from '@orpc/interop/json-schema-typed/draft-2020-12';
 
 const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
 function customOpenAPIOperation(o, extend) {
@@ -114,13 +114,18 @@ function isAnySchema(schema) {
   return false;
 }
 function separateObjectSchema(schema, separatedProperties) {
-  if (Object.keys(schema).some((k) => k !== "type" && k !== "properties" && k !== "required" && LOGIC_KEYWORDS.includes(k))) {
+  if (Object.keys(schema).some(
+    (k) => !["type", "properties", "required", "additionalProperties"].includes(k) && LOGIC_KEYWORDS.includes(k) && schema[k] !== void 0
+  )) {
     return [{ type: "object" }, schema];
   }
   const matched = { ...schema };
   const rest = { ...schema };
-  matched.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => separatedProperties.includes(key)).reduce((acc, [key, value]) => {
-    acc[key] = value;
+  matched.properties = separatedProperties.reduce((acc, key) => {
+    const keySchema = schema.properties?.[key] ?? schema.additionalProperties;
+    if (keySchema !== void 0) {
+      acc[key] = keySchema;
+    }
     return acc;
   }, {});
   matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
@@ -345,6 +350,116 @@ function checkParamsSchema(schema, params) {
 function toOpenAPISchema(schema) {
   return schema === true ? {} : schema === false ? { not: {} } : schema;
 }
+const OPENAPI_JSON_SCHEMA_REF_PREFIX = "#/components/schemas/";
+function resolveOpenAPIJsonSchemaRef(doc, schema) {
+  if (typeof schema !== "object" || !schema.$ref?.startsWith(OPENAPI_JSON_SCHEMA_REF_PREFIX)) {
+    return schema;
+  }
+  const name = schema.$ref.slice(OPENAPI_JSON_SCHEMA_REF_PREFIX.length);
+  const resolved = doc.components?.schemas?.[name];
+  return resolved ?? schema;
+}
+function simplifyComposedObjectJsonSchemasAndRefs(schema, doc) {
+  if (doc) {
+    schema = resolveOpenAPIJsonSchemaRef(doc, schema);
+  }
+  if (typeof schema !== "object" || !schema.anyOf && !schema.oneOf && !schema.allOf) {
+    return schema;
+  }
+  const unionSchemas = [
+    ...toArray(schema.anyOf?.map((s) => simplifyComposedObjectJsonSchemasAndRefs(s, doc))),
+    ...toArray(schema.oneOf?.map((s) => simplifyComposedObjectJsonSchemasAndRefs(s, doc)))
+  ];
+  const objectUnionSchemas = [];
+  for (const u of unionSchemas) {
+    if (!isObjectSchema(u)) {
+      return schema;
+    }
+    objectUnionSchemas.push(u);
+  }
+  const mergedUnionPropertyMap = /* @__PURE__ */ new Map();
+  for (const u of objectUnionSchemas) {
+    if (u.properties) {
+      for (const [key, value] of Object.entries(u.properties)) {
+        let entry = mergedUnionPropertyMap.get(key);
+        if (!entry) {
+          const required = objectUnionSchemas.every((s) => s.required?.includes(key));
+          entry = { required, schemas: [] };
+          mergedUnionPropertyMap.set(key, entry);
+        }
+        entry.schemas.push(value);
+      }
+    }
+  }
+  const intersectionSchemas = toArray(schema.allOf?.map((s) => simplifyComposedObjectJsonSchemasAndRefs(s, doc)));
+  const objectIntersectionSchemas = [];
+  for (const u of intersectionSchemas) {
+    if (!isObjectSchema(u)) {
+      return schema;
+    }
+    objectIntersectionSchemas.push(u);
+  }
+  if (isObjectSchema(schema)) {
+    objectIntersectionSchemas.push(schema);
+  }
+  const mergedInteractionPropertyMap = /* @__PURE__ */ new Map();
+  for (const u of objectIntersectionSchemas) {
+    if (u.properties) {
+      for (const [key, value] of Object.entries(u.properties)) {
+        let entry = mergedInteractionPropertyMap.get(key);
+        if (!entry) {
+          const required = objectIntersectionSchemas.some((s) => s.required?.includes(key));
+          entry = { required, schemas: [] };
+          mergedInteractionPropertyMap.set(key, entry);
+        }
+        entry.schemas.push(value);
+      }
+    }
+  }
+  const resultObjectSchema = { type: "object", properties: {}, required: [] };
+  const keys = /* @__PURE__ */ new Set([
+    ...mergedUnionPropertyMap.keys(),
+    ...mergedInteractionPropertyMap.keys()
+  ]);
+  if (keys.size === 0) {
+    return schema;
+  }
+  const deduplicateSchemas = (schemas) => {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const schema2 of schemas) {
+      const key = stringifyJSON(schema2);
+      if (!seen.has(key)) {
+        seen.add(key);
+        result.push(schema2);
+      }
+    }
+    return result;
+  };
+  for (const key of keys) {
+    const unionEntry = mergedUnionPropertyMap.get(key);
+    const intersectionEntry = mergedInteractionPropertyMap.get(key);
+    resultObjectSchema.properties[key] = (() => {
+      const dedupedUnionSchemas = unionEntry ? deduplicateSchemas(unionEntry.schemas) : [];
+      const dedupedIntersectionSchemas = intersectionEntry ? deduplicateSchemas(intersectionEntry.schemas) : [];
+      if (!dedupedUnionSchemas.length) {
+        return dedupedIntersectionSchemas.length === 1 ? dedupedIntersectionSchemas[0] : { allOf: dedupedIntersectionSchemas };
+      }
+      if (!dedupedIntersectionSchemas.length) {
+        return dedupedUnionSchemas.length === 1 ? dedupedUnionSchemas[0] : { anyOf: dedupedUnionSchemas };
+      }
+      const allOf = deduplicateSchemas([
+        ...dedupedIntersectionSchemas,
+        dedupedUnionSchemas.length === 1 ? dedupedUnionSchemas[0] : { anyOf: dedupedUnionSchemas }
+      ]);
+      return allOf.length === 1 ? allOf[0] : { allOf };
+    })();
+    if (unionEntry?.required || intersectionEntry?.required) {
+      resultObjectSchema.required.push(key);
+    }
+  }
+  return resultObjectSchema;
+}
 
 class CompositeSchemaConverter {
   converters;
@@ -375,37 +490,48 @@ class OpenAPIGenerator {
    *
    * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
    */
-  async generate(router, options = {}) {
-    const exclude = options.exclude ?? (() => false);
+  async generate(router, { customErrorResponseBodySchema, commonSchemas, filter: baseFilter, exclude, ...baseDoc } = {}) {
+    const filter = baseFilter ?? (({ contract, path }) => {
+      return !(exclude?.(contract, path) ?? false);
+    });
     const doc = {
-      ...clone(options),
-      info: options.info ?? { title: "API Reference", version: "0.0.0" },
-      openapi: "3.1.1",
-      exclude: void 0
+      ...clone(baseDoc),
+      info: baseDoc.info ?? { title: "API Reference", version: "0.0.0" },
+      openapi: "3.1.1"
     };
+    const { baseSchemaConvertOptions, undefinedErrorJsonSchema } = await this.#resolveCommonSchemas(doc, commonSchemas);
     const contracts = [];
-    await resolveContractProcedures({ path: [], router }, ({ contract, path }) => {
-      if (!exclude(contract, path)) {
-        contracts.push({ contract, path });
+    await resolveContractProcedures({ path: [], router }, (traverseOptions) => {
+      if (!value(filter, traverseOptions)) {
+        return;
       }
+      contracts.push(traverseOptions);
     });
     const errors = [];
     for (const { contract, path } of contracts) {
-      const operationId = path.join(".");
+      const stringPath = path.join(".");
       try {
         const def = contract["~orpc"];
         const method = toOpenAPIMethod(fallbackContractConfig("defaultMethod", def.route.method));
         const httpPath = toOpenAPIPath(def.route.path ?? toHttpPath(path));
-        const operationObjectRef = {
-          operationId,
-          summary: def.route.summary,
-          description: def.route.description,
-          deprecated: def.route.deprecated,
-          tags: def.route.tags?.map((tag) => tag)
-        };
-        await this.#request(operationObjectRef, def);
-        await this.#successResponse(operationObjectRef, def);
-        await this.#errorResponse(operationObjectRef, def);
+        let operationObjectRef;
+        if (def.route.spec !== void 0 && typeof def.route.spec !== "function") {
+          operationObjectRef = def.route.spec;
+        } else {
+          operationObjectRef = {
+            operationId: def.route.operationId ?? stringPath,
+            summary: def.route.summary,
+            description: def.route.description,
+            deprecated: def.route.deprecated,
+            tags: def.route.tags?.map((tag) => tag)
+          };
+          await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
+          await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
+          await this.#errorResponse(operationObjectRef, def, baseSchemaConvertOptions, undefinedErrorJsonSchema, customErrorResponseBodySchema);
+        }
+        if (typeof def.route.spec === "function") {
+          operationObjectRef = def.route.spec(operationObjectRef);
+        }
         doc.paths ??= {};
         doc.paths[httpPath] ??= {};
         doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
@@ -414,7 +540,7 @@ class OpenAPIGenerator {
           throw e;
         }
         errors.push(
-          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${operationId}
+          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${stringPath}
 ${e.message}`
         );
       }
@@ -428,25 +554,101 @@ ${errors.join("\n\n")}`
     }
     return this.serializer.serialize(doc)[0];
   }
-  async #request(ref, def) {
+  async #resolveCommonSchemas(doc, commonSchemas) {
+    let undefinedErrorJsonSchema = {
+      type: "object",
+      properties: {
+        defined: { const: false },
+        code: { type: "string" },
+        status: { type: "number" },
+        message: { type: "string" },
+        data: {}
+      },
+      required: ["defined", "code", "status", "message"]
+    };
+    const baseSchemaConvertOptions = {};
+    if (commonSchemas) {
+      baseSchemaConvertOptions.components = [];
+      for (const key in commonSchemas) {
+        const options = commonSchemas[key];
+        if (options.schema === void 0) {
+          continue;
+        }
+        const { schema, strategy = "input" } = options;
+        const [required, json] = await this.converter.convert(schema, { strategy });
+        const allowedStrategies = [strategy];
+        if (strategy === "input") {
+          const [outputRequired, outputJson] = await this.converter.convert(schema, { strategy: "output" });
+          if (outputRequired === required && stringifyJSON(outputJson) === stringifyJSON(json)) {
+            allowedStrategies.push("output");
+          }
+        } else if (strategy === "output") {
+          const [inputRequired, inputJson] = await this.converter.convert(schema, { strategy: "input" });
+          if (inputRequired === required && stringifyJSON(inputJson) === stringifyJSON(json)) {
+            allowedStrategies.push("input");
+          }
+        }
+        baseSchemaConvertOptions.components.push({
+          schema,
+          required,
+          ref: `#/components/schemas/${key}`,
+          allowedStrategies
+        });
+      }
+      doc.components ??= {};
+      doc.components.schemas ??= {};
+      for (const key in commonSchemas) {
+        const options = commonSchemas[key];
+        if (options.schema === void 0) {
+          if (options.error === "UndefinedError") {
+            doc.components.schemas[key] = toOpenAPISchema(undefinedErrorJsonSchema);
+            undefinedErrorJsonSchema = { $ref: `#/components/schemas/${key}` };
+          }
+          continue;
+        }
+        const { schema, strategy = "input" } = options;
+        const [, json] = await this.converter.convert(
+          schema,
+          {
+            ...baseSchemaConvertOptions,
+            strategy,
+            minStructureDepthForRef: 1
+            // not allow use $ref for root schemas
+          }
+        );
+        doc.components.schemas[key] = toOpenAPISchema(json);
+      }
+    }
+    return { baseSchemaConvertOptions, undefinedErrorJsonSchema };
+  }
+  async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
     const details = getEventIteratorSchemaDetails(def.inputSchema);
     if (details) {
       ref.requestBody = {
         required: true,
         content: toOpenAPIEventIteratorContent(
-          await this.converter.convert(details.yields, { strategy: "input" }),
-          await this.converter.convert(details.returns, { strategy: "input" })
+          await this.converter.convert(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
+          await this.converter.convert(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
         )
       };
       return;
     }
     const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
     const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
-    let [required, schema] = await this.converter.convert(def.inputSchema, { strategy: "input" });
+    let [required, schema] = await this.converter.convert(
+      def.inputSchema,
+      {
+        ...baseSchemaConvertOptions,
+        strategy: "input"
+      }
+    );
     if (isAnySchema(schema) && !dynamicParams?.length) {
       return;
     }
+    if (inputStructure === "detailed" || inputStructure === "compact" && (dynamicParams?.length || method === "GET")) {
+      schema = simplifyComposedObjectJsonSchemasAndRefs(schema, doc);
+    }
     if (inputStructure === "compact") {
       if (dynamicParams?.length) {
         const error2 = new OpenAPIGeneratorError(
@@ -486,7 +688,8 @@ ${errors.join("\n\n")}`
     if (!isObjectSchema(schema)) {
       throw error;
     }
-    if (dynamicParams?.length && (schema.properties?.params === void 0 || !isObjectSchema(schema.properties.params) || !checkParamsSchema(schema.properties.params, dynamicParams))) {
+    const resolvedParamSchema = schema.properties?.params !== void 0 ? simplifyComposedObjectJsonSchemasAndRefs(schema.properties.params, doc) : void 0;
+    if (dynamicParams?.length && (resolvedParamSchema === void 0 || !isObjectSchema(resolvedParamSchema) || !checkParamsSchema(resolvedParamSchema, dynamicParams))) {
       throw new OpenAPIGeneratorError(
         'When input structure is "detailed" and path has dynamic params, the "params" schema must be an object with all dynamic params as required.'
       );
@@ -494,12 +697,13 @@ ${errors.join("\n\n")}`
     for (const from of ["params", "query", "headers"]) {
       const fromSchema = schema.properties?.[from];
       if (fromSchema !== void 0) {
-        if (!isObjectSchema(fromSchema)) {
+        const resolvedSchema = simplifyComposedObjectJsonSchemasAndRefs(fromSchema, doc);
+        if (!isObjectSchema(resolvedSchema)) {
           throw error;
         }
         const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
         ref.parameters ??= [];
-        ref.parameters.push(...toOpenAPIParameters(fromSchema, parameterIn));
+        ref.parameters.push(...toOpenAPIParameters(resolvedSchema, parameterIn));
       }
     }
     if (schema.properties?.body !== void 0) {
@@ -509,7 +713,7 @@ ${errors.join("\n\n")}`
       };
     }
   }
-  async #successResponse(ref, def) {
+  async #successResponse(doc, ref, def, baseSchemaConvertOptions) {
     const outputSchema = def.outputSchema;
     const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
     const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
@@ -520,13 +724,20 @@ ${errors.join("\n\n")}`
       ref.responses[status] = {
         description,
         content: toOpenAPIEventIteratorContent(
-          await this.converter.convert(eventIteratorSchemaDetails.yields, { strategy: "output" }),
-          await this.converter.convert(eventIteratorSchemaDetails.returns, { strategy: "output" })
+          await this.converter.convert(eventIteratorSchemaDetails.yields, { ...baseSchemaConvertOptions, strategy: "output" }),
+          await this.converter.convert(eventIteratorSchemaDetails.returns, { ...baseSchemaConvertOptions, strategy: "output" })
         )
       };
       return;
     }
-    const [required, json] = await this.converter.convert(outputSchema, { strategy: "output" });
+    const [required, json] = await this.converter.convert(
+      outputSchema,
+      {
+        ...baseSchemaConvertOptions,
+        strategy: "output",
+        minStructureDepthForRef: outputStructure === "detailed" ? 1 : 0
+      }
+    );
     if (outputStructure === "compact") {
       ref.responses ??= {};
       ref.responses[status] = {
@@ -547,17 +758,19 @@ ${errors.join("\n\n")}`
         
         But got: ${stringifyJSON(item)}
       `);
-      if (!isObjectSchema(item)) {
+      const simplifiedItem = simplifyComposedObjectJsonSchemasAndRefs(item, doc);
+      if (!isObjectSchema(simplifiedItem)) {
         throw error;
       }
       let schemaStatus;
       let schemaDescription;
-      if (item.properties?.status !== void 0) {
-        if (typeof item.properties.status !== "object" || item.properties.status.const === void 0 || typeof item.properties.status.const !== "number" || !Number.isInteger(item.properties.status.const) || isORPCErrorStatus(item.properties.status.const)) {
+      if (simplifiedItem.properties?.status !== void 0) {
+        const statusSchema = resolveOpenAPIJsonSchemaRef(doc, simplifiedItem.properties.status);
+        if (typeof statusSchema !== "object" || statusSchema.const === void 0 || typeof statusSchema.const !== "number" || !Number.isInteger(statusSchema.const) || isORPCErrorStatus(statusSchema.const)) {
           throw error;
         }
-        schemaStatus = item.properties.status.const;
-        schemaDescription = item.properties.status.description;
+        schemaStatus = statusSchema.const;
+        schemaDescription = statusSchema.description;
       }
       const itemStatus = schemaStatus ?? status;
       const itemDescription = schemaDescription ?? description;
@@ -572,71 +785,64 @@ ${errors.join("\n\n")}`
       ref.responses[itemStatus] = {
         description: itemDescription
       };
-      if (item.properties?.headers !== void 0) {
-        if (!isObjectSchema(item.properties.headers)) {
+      if (simplifiedItem.properties?.headers !== void 0) {
+        const headersSchema = simplifyComposedObjectJsonSchemasAndRefs(simplifiedItem.properties.headers, doc);
+        if (!isObjectSchema(headersSchema)) {
           throw error;
         }
-        for (const key in item.properties.headers.properties) {
-          const headerSchema = item.properties.headers.properties[key];
+        for (const key in headersSchema.properties) {
+          const headerSchema = headersSchema.properties[key];
           if (headerSchema !== void 0) {
             ref.responses[itemStatus].headers ??= {};
             ref.responses[itemStatus].headers[key] = {
               schema: toOpenAPISchema(headerSchema),
-              required: item.properties.headers.required?.includes(key)
+              required: simplifiedItem.required?.includes("headers") && headersSchema.required?.includes(key)
             };
           }
         }
       }
-      if (item.properties?.body !== void 0) {
+      if (simplifiedItem.properties?.body !== void 0) {
         ref.responses[itemStatus].content = toOpenAPIContent(
-          applySchemaOptionality(item.required?.includes("body") ?? false, item.properties.body)
+          applySchemaOptionality(simplifiedItem.required?.includes("body") ?? false, simplifiedItem.properties.body)
         );
       }
     }
   }
-  async #errorResponse(ref, def) {
+  async #errorResponse(ref, def, baseSchemaConvertOptions, undefinedErrorSchema, customErrorResponseBodySchema) {
     const errorMap = def.errorMap;
-    const errors = {};
+    const errorResponsesByStatus = {};
     for (const code in errorMap) {
       const config = errorMap[code];
       if (!config) {
         continue;
       }
       const status = fallbackORPCErrorStatus(code, config.status);
-      const message = fallbackORPCErrorMessage(code, config.message);
-      const [dataRequired, dataSchema] = await this.converter.convert(config.data, { strategy: "output" });
-      errors[status] ??= [];
-      errors[status].push({
+      const defaultMessage = fallbackORPCErrorMessage(code, config.message);
+      errorResponsesByStatus[status] ??= { status, definedErrorDefinitions: [], errorSchemaVariants: [] };
+      const [dataRequired, dataSchema] = await this.converter.convert(config.data, { ...baseSchemaConvertOptions, strategy: "output" });
+      errorResponsesByStatus[status].definedErrorDefinitions.push([code, defaultMessage, dataRequired, dataSchema]);
+      errorResponsesByStatus[status].errorSchemaVariants.push({
         type: "object",
         properties: {
           defined: { const: true },
           code: { const: code },
           status: { const: status },
-          message: { type: "string", default: message },
+          message: { type: "string", default: defaultMessage },
           data: dataSchema
         },
         required: dataRequired ? ["defined", "code", "status", "message", "data"] : ["defined", "code", "status", "message"]
       });
     }
     ref.responses ??= {};
-    for (const status in errors) {
-      const schemas = errors[status];
-      ref.responses[status] = {
-        description: status,
-        content: toOpenAPIContent({
+    for (const statusString in errorResponsesByStatus) {
+      const errorResponse = errorResponsesByStatus[statusString];
+      const customBodySchema = value(customErrorResponseBodySchema, errorResponse.definedErrorDefinitions, errorResponse.status);
+      ref.responses[statusString] = {
+        description: statusString,
+        content: toOpenAPIContent(customBodySchema ?? {
           oneOf: [
-            ...schemas,
-            {
-              type: "object",
-              properties: {
-                defined: { const: false },
-                code: { type: "string" },
-                status: { type: "number" },
-                message: { type: "string" },
-                data: {}
-              },
-              required: ["defined", "code", "status", "message"]
-            }
+            ...errorResponse.errorSchemaVariants,
+            undefinedErrorSchema
           ]
         })
       };
@@ -644,4 +850,4 @@ ${errors.join("\n\n")}`
   }
 }
 
-export { CompositeSchemaConverter as C, LOGIC_KEYWORDS as L, OpenAPIGenerator as O, applyCustomOpenAPIOperation as a, toOpenAPIMethod as b, customOpenAPIOperation as c, toOpenAPIContent as d, toOpenAPIEventIteratorContent as e, toOpenAPIParameters as f, getCustomOpenAPIOperation as g, checkParamsSchema as h, toOpenAPISchema as i, isFileSchema as j, isObjectSchema as k, isAnySchema as l, filterSchemaBranches as m, applySchemaOptionality as n, expandUnionSchema as o, expandArrayableSchema as p, isPrimitiveSchema as q, separateObjectSchema as s, toOpenAPIPath as t };
+export { CompositeSchemaConverter as C, LOGIC_KEYWORDS as L, OpenAPIGenerator as O, applyCustomOpenAPIOperation as a, toOpenAPIMethod as b, customOpenAPIOperation as c, toOpenAPIContent as d, toOpenAPIEventIteratorContent as e, toOpenAPIParameters as f, getCustomOpenAPIOperation as g, checkParamsSchema as h, toOpenAPISchema as i, isFileSchema as j, isObjectSchema as k, isAnySchema as l, separateObjectSchema as m, filterSchemaBranches as n, applySchemaOptionality as o, expandUnionSchema as p, expandArrayableSchema as q, resolveOpenAPIJsonSchemaRef as r, simplifyComposedObjectJsonSchemasAndRefs as s, toOpenAPIPath as t, isPrimitiveSchema as u };

package/dist/shared/{openapi.C_UtQ8Us.mjs → openapi.DIt-Z9W1.mjs}

@@ -2,15 +2,17 @@ import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, StandardBracketNota
 import { StandardHandler } from '@orpc/server/standard';
 import { isORPCErrorStatus } from '@orpc/client';
 import { fallbackContractConfig } from '@orpc/contract';
-import { isObject, stringifyJSON } from '@orpc/shared';
+import { isObject, stringifyJSON, tryDecodeURIComponent, value } from '@orpc/shared';
 import { toHttpPath } from '@orpc/client/standard';
 import { traverseContractProcedures, isProcedure, getLazyMeta, unlazy, getRouter, createContractedProcedure } from '@orpc/server';
 import { createRouter, addRoute, findRoute } from 'rou3';
 
 class StandardOpenAPICodec {
-  constructor(serializer) {
+  constructor(serializer, options = {}) {
     this.serializer = serializer;
+    this.customErrorResponseBodyEncoder = options.customErrorResponseBodyEncoder;
   }
+  customErrorResponseBodyEncoder;
   async decode(request, params, procedure) {
     const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
     if (inputStructure === "compact") {
@@ -73,10 +75,11 @@ class StandardOpenAPICodec {
     };
   }
   encodeError(error) {
+    const body = this.customErrorResponseBodyEncoder?.(error) ?? error.toJSON();
     return {
       status: error.status,
       headers: {},
-      body: this.serializer.serialize(error.toJSON(), { outputFormat: "plain" })
+      body: this.serializer.serialize(body, { outputFormat: "plain" })
     };
   }
   #isDetailedOutput(output) {
@@ -97,14 +100,22 @@ function toRou3Pattern(path) {
   return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
 }
 function decodeParams(params) {
-  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, decodeURIComponent(value)]));
+  return Object.fromEntries(Object.entries(params).map(([key, value]) => [key, tryDecodeURIComponent(value)]));
 }
 
 class StandardOpenAPIMatcher {
+  filter;
   tree = createRouter();
   pendingRouters = [];
+  constructor(options = {}) {
+    this.filter = options.filter ?? true;
+  }
   init(router, path = []) {
-    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+    const laziedOptions = traverseContractProcedures({ router, path }, (traverseOptions) => {
+      if (!value(this.filter, traverseOptions)) {
+        return;
+      }
+      const { path: path2, contract } = traverseOptions;
       const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
       const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
       if (isProcedure(contract)) {
@@ -168,10 +179,10 @@ class StandardOpenAPIMatcher {
 class StandardOpenAPIHandler extends StandardHandler {
   constructor(router, options) {
     const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
-    const bracketNotationSerializer = new StandardBracketNotationSerializer();
+    const bracketNotationSerializer = new StandardBracketNotationSerializer(options);
     const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
-    const matcher = new StandardOpenAPIMatcher();
-    const codec = new StandardOpenAPICodec(serializer);
+    const matcher = new StandardOpenAPIMatcher(options);
+    const codec = new StandardOpenAPICodec(serializer, options);
     super(router, matcher, codec, options);
   }
 }

package/dist/shared/openapi.DwaweYRb.d.mts

@@ -0,0 +1,54 @@
+import { StandardOpenAPISerializer, StandardOpenAPIJsonSerializerOptions, StandardBracketNotationSerializerOptions } from '@orpc/openapi-client/standard';
+import { AnyProcedure, TraverseContractProcedureCallbackOptions, AnyRouter, Context, Router } from '@orpc/server';
+import { StandardCodec, StandardParams, StandardMatcher, StandardMatchResult, StandardHandlerOptions, StandardHandler } from '@orpc/server/standard';
+import { ORPCError, HTTPPath } from '@orpc/client';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { Value } from '@orpc/shared';
+
+interface StandardOpenAPICodecOptions {
+    /**
+     * Customize how an ORPC error is encoded into a response body.
+     * Use this if your API needs a different error output structure.
+     *
+     * @remarks
+     * - Return `null | undefined` to fallback to default behavior
+     *
+     * @default ((e) => e.toJSON())
+     */
+    customErrorResponseBodyEncoder?: (error: ORPCError<any, any>) => unknown;
+}
+declare class StandardOpenAPICodec implements StandardCodec {
+    #private;
+    private readonly serializer;
+    private readonly customErrorResponseBodyEncoder;
+    constructor(serializer: StandardOpenAPISerializer, options?: StandardOpenAPICodecOptions);
+    decode(request: StandardLazyRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+interface StandardOpenAPIMatcherOptions {
+    /**
+     * Filter procedures. Return `false` to exclude a procedure from matching.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [options: TraverseContractProcedureCallbackOptions]>;
+}
+declare class StandardOpenAPIMatcher implements StandardMatcher {
+    private readonly filter;
+    private readonly tree;
+    private pendingRouters;
+    constructor(options?: StandardOpenAPIMatcherOptions);
+    init(router: AnyRouter, path?: readonly string[]): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+
+interface StandardOpenAPIHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardOpenAPIJsonSerializerOptions, StandardBracketNotationSerializerOptions, StandardOpenAPIMatcherOptions, StandardOpenAPICodecOptions {
+}
+declare class StandardOpenAPIHandler<T extends Context> extends StandardHandler<T> {
+    constructor(router: Router<any, T>, options: NoInfer<StandardOpenAPIHandlerOptions<T>>);
+}
+
+export { StandardOpenAPICodec as a, StandardOpenAPIHandler as c, StandardOpenAPIMatcher as e };
+export type { StandardOpenAPICodecOptions as S, StandardOpenAPIHandlerOptions as b, StandardOpenAPIMatcherOptions as d };