@orpc/openapi 0.0.0-next.1b95eee → 0.0.0-next.1bc0bef

package/dist/shared/{openapi.C_3bk7bB.mjs → openapi.CoREqFh3.mjs}

@@ -3,7 +3,7 @@ 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 { isObject, stringifyJSON, findDeepMatches, toArray, clone, value } from '@orpc/shared';
 import { TypeName } from 'json-schema-typed/draft-2020-12';
 
 const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
@@ -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));
@@ -354,6 +359,107 @@ function resolveOpenAPIJsonSchemaRef(doc, schema) {
   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;
@@ -382,37 +488,38 @@ class OpenAPIGenerator {
   /**
    * Generates OpenAPI specifications from oRPC routers/contracts.
    *
-   * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification OpenAPI Specification Docs}
+   * @see {@link https://orpc.dev/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,
-      commonSchemas: void 0
+      ...clone(baseDoc),
+      info: baseDoc.info ?? { title: "API Reference", version: "0.0.0" },
+      openapi: "3.1.1"
     };
-    const baseSchemaConvertOptions = await this.#resolveCommonSchemas(doc, options.commonSchemas);
+    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));
         let operationObjectRef;
-        if (def.route.spec !== void 0) {
+        if (def.route.spec !== void 0 && typeof def.route.spec !== "function") {
           operationObjectRef = def.route.spec;
         } else {
           operationObjectRef = {
-            operationId,
+            operationId: def.route.operationId ?? stringPath,
             summary: def.route.summary,
             description: def.route.description,
             deprecated: def.route.deprecated,
@@ -420,7 +527,10 @@ class OpenAPIGenerator {
           };
           await this.#request(doc, operationObjectRef, def, baseSchemaConvertOptions);
           await this.#successResponse(doc, operationObjectRef, def, baseSchemaConvertOptions);
-          await this.#errorResponse(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] ??= {};
@@ -430,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}`
         );
       }
@@ -445,11 +555,26 @@ ${errors.join("\n\n")}`
     return this.serializer.serialize(doc)[0];
   }
   async #resolveCommonSchemas(doc, commonSchemas) {
-    const baseOptions = {};
+    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) {
-      baseOptions.components = [];
+      baseSchemaConvertOptions.components = [];
       for (const key in commonSchemas) {
-        const { schema, strategy = "input" } = commonSchemas[key];
+        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") {
@@ -463,7 +588,7 @@ ${errors.join("\n\n")}`
             allowedStrategies.push("input");
           }
         }
-        baseOptions.components.push({
+        baseSchemaConvertOptions.components.push({
           schema,
           required,
           ref: `#/components/schemas/${key}`,
@@ -473,11 +598,19 @@ ${errors.join("\n\n")}`
       doc.components ??= {};
       doc.components.schemas ??= {};
       for (const key in commonSchemas) {
-        const { schema, strategy = "input" } = commonSchemas[key];
+        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,
           {
-            ...baseOptions,
+            ...baseSchemaConvertOptions,
             strategy,
             minStructureDepthForRef: 1
             // not allow use $ref for root schemas
@@ -486,7 +619,7 @@ ${errors.join("\n\n")}`
         doc.components.schemas[key] = toOpenAPISchema(json);
       }
     }
-    return baseOptions;
+    return { baseSchemaConvertOptions, undefinedErrorJsonSchema };
   }
   async #request(doc, ref, def, baseSchemaConvertOptions) {
     const method = fallbackContractConfig("defaultMethod", def.route.method);
@@ -507,13 +640,15 @@ ${errors.join("\n\n")}`
       def.inputSchema,
       {
         ...baseSchemaConvertOptions,
-        strategy: "input",
-        minStructureDepthForRef: dynamicParams?.length || inputStructure === "detailed" ? 1 : 0
+        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(
@@ -553,7 +688,7 @@ ${errors.join("\n\n")}`
     if (!isObjectSchema(schema)) {
       throw error;
     }
-    const resolvedParamSchema = schema.properties?.params !== void 0 ? resolveOpenAPIJsonSchemaRef(doc, schema.properties.params) : void 0;
+    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.'
@@ -562,7 +697,7 @@ ${errors.join("\n\n")}`
     for (const from of ["params", "query", "headers"]) {
       const fromSchema = schema.properties?.[from];
       if (fromSchema !== void 0) {
-        const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, fromSchema);
+        const resolvedSchema = simplifyComposedObjectJsonSchemasAndRefs(fromSchema, doc);
         if (!isObjectSchema(resolvedSchema)) {
           throw error;
         }
@@ -623,13 +758,14 @@ ${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) {
-        const statusSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.status);
+      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;
         }
@@ -649,8 +785,8 @@ ${errors.join("\n\n")}`
       ref.responses[itemStatus] = {
         description: itemDescription
       };
-      if (item.properties?.headers !== void 0) {
-        const headersSchema = resolveOpenAPIJsonSchemaRef(doc, item.properties.headers);
+      if (simplifiedItem.properties?.headers !== void 0) {
+        const headersSchema = simplifyComposedObjectJsonSchemasAndRefs(simplifiedItem.properties.headers, doc);
         if (!isObjectSchema(headersSchema)) {
           throw error;
         }
@@ -660,61 +796,53 @@ ${errors.join("\n\n")}`
             ref.responses[itemStatus].headers ??= {};
             ref.responses[itemStatus].headers[key] = {
               schema: toOpenAPISchema(headerSchema),
-              required: item.required?.includes("headers") && headersSchema.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, baseSchemaConvertOptions) {
+  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 defaultMessage = fallbackORPCErrorMessage(code, config.message);
+      errorResponsesByStatus[status] ??= { status, definedErrorDefinitions: [], errorSchemaVariants: [] };
       const [dataRequired, dataSchema] = await this.converter.convert(config.data, { ...baseSchemaConvertOptions, strategy: "output" });
-      errors[status] ??= [];
-      errors[status].push({
+      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
           ]
         })
       };
@@ -722,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, resolveOpenAPIJsonSchemaRef as r, 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 };

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

@@ -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 };