@orpc/openapi 0.0.0-next.f17a1a0 → 0.0.0-next.f47352c

package/dist/index.mjs

@@ -0,0 +1,536 @@
+import { isProcedure, resolveContractProcedures } from '@orpc/server';
+import { fallbackORPCErrorStatus, fallbackORPCErrorMessage } from '@orpc/client';
+import { toHttpPath } from '@orpc/client/standard';
+import { fallbackContractConfig, getEventIteratorSchemaDetails } from '@orpc/contract';
+import { standardizeHTTPPath, StandardOpenAPIJsonSerializer, getDynamicParams } from '@orpc/openapi-client/standard';
+import { isObject, findDeepMatches, toArray, clone } from '@orpc/shared';
+export { Format as JSONSchemaFormat } from 'json-schema-typed/draft-2020-12';
+
+const OPERATION_EXTENDER_SYMBOL = Symbol("ORPC_OPERATION_EXTENDER");
+function customOpenAPIOperation(o, extend) {
+  return new Proxy(o, {
+    get(target, prop, receiver) {
+      if (prop === OPERATION_EXTENDER_SYMBOL) {
+        return extend;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getCustomOpenAPIOperation(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function applyCustomOpenAPIOperation(operation, contract) {
+  const operationCustoms = [];
+  for (const errorItem of Object.values(contract["~orpc"].errorMap)) {
+    const maybeExtender = errorItem ? getCustomOpenAPIOperation(errorItem) : void 0;
+    if (maybeExtender) {
+      operationCustoms.push(maybeExtender);
+    }
+  }
+  if (isProcedure(contract)) {
+    for (const middleware of contract["~orpc"].middlewares) {
+      const maybeExtender = getCustomOpenAPIOperation(middleware);
+      if (maybeExtender) {
+        operationCustoms.push(maybeExtender);
+      }
+    }
+  }
+  let currentOperation = operation;
+  for (const custom of operationCustoms) {
+    if (typeof custom === "function") {
+      currentOperation = custom(currentOperation, contract);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...custom
+      };
+    }
+  }
+  return currentOperation;
+}
+
+const LOGIC_KEYWORDS = [
+  "$dynamicRef",
+  "$ref",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "dependencies",
+  "dependentRequired",
+  "dependentSchemas",
+  "else",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maximum",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minContains",
+  "minimum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "required",
+  "then",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems"
+];
+
+function isFileSchema(schema) {
+  return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
+function isObjectSchema(schema) {
+  return isObject(schema) && schema.type === "object";
+}
+function isAnySchema(schema) {
+  if (schema === true) {
+    return true;
+  }
+  if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) {
+    return true;
+  }
+  return false;
+}
+function separateObjectSchema(schema, separatedProperties) {
+  if (Object.keys(schema).some((k) => k !== "type" && k !== "properties" && k !== "required" && LOGIC_KEYWORDS.includes(k))) {
+    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;
+    return acc;
+  }, {});
+  matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
+  matched.examples = schema.examples?.map((example) => {
+    if (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value]) => {
+      if (separatedProperties.includes(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+  rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
+  rest.examples = schema.examples?.map((example) => {
+    if (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce((acc, [key, value]) => {
+      if (!separatedProperties.includes(key)) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+  });
+  return [matched, rest];
+}
+function filterSchemaBranches(schema, check, matches = []) {
+  if (check(schema)) {
+    matches.push(schema);
+    return [matches, void 0];
+  }
+  if (isObject(schema)) {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every(
+        (k) => k === keyword || !LOGIC_KEYWORDS.includes(k)
+      )) {
+        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
+        if (rest.length === 1 && typeof rest[0] === "object") {
+          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];
+        }
+        return [matches, { ...schema, [keyword]: rest }];
+      }
+    }
+  }
+  return [matches, schema];
+}
+function applySchemaOptionality(required, schema) {
+  if (required) {
+    return schema;
+  }
+  return {
+    anyOf: [
+      schema,
+      { not: {} }
+    ]
+  };
+}
+
+function toOpenAPIPath(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
+}
+function toOpenAPIMethod(method) {
+  return method.toLocaleLowerCase();
+}
+function toOpenAPIContent(schema) {
+  const content = {};
+  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
+  for (const file of matches) {
+    content[file.contentMediaType] = {
+      schema: toOpenAPISchema(file)
+    };
+  }
+  if (restSchema !== void 0) {
+    content["application/json"] = {
+      schema: toOpenAPISchema(restSchema)
+    };
+    const isStillHasFileSchema = findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0;
+    if (isStillHasFileSchema) {
+      content["multipart/form-data"] = {
+        schema: toOpenAPISchema(restSchema)
+      };
+    }
+  }
+  return content;
+}
+function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
+  return {
+    "text/event-stream": {
+      schema: toOpenAPISchema({
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              event: { const: "message" },
+              data: yieldsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: yieldsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "done" },
+              data: returnsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: returnsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "error" },
+              data: {},
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: ["event"]
+          }
+        ]
+      })
+    }
+  };
+}
+function toOpenAPIParameters(schema, parameterIn) {
+  const parameters = [];
+  for (const key in schema.properties) {
+    const keySchema = schema.properties[key];
+    parameters.push({
+      name: key,
+      in: parameterIn,
+      required: schema.required?.includes(key),
+      style: parameterIn === "query" ? "deepObject" : void 0,
+      explode: parameterIn === "query" ? true : void 0,
+      schema: toOpenAPISchema(keySchema)
+    });
+  }
+  return parameters;
+}
+function checkParamsSchema(schema, params) {
+  const properties = Object.keys(schema.properties ?? {});
+  const required = schema.required ?? [];
+  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {
+    return false;
+  }
+  if (required.length !== params.length || required.some((v) => !params.includes(v))) {
+    return false;
+  }
+  return true;
+}
+function toOpenAPISchema(schema) {
+  return schema === true ? {} : schema === false ? { not: {} } : schema;
+}
+
+class CompositeSchemaConverter {
+  converters;
+  constructor(converters) {
+    this.converters = converters;
+  }
+  convert(schema, options) {
+    for (const converter of this.converters) {
+      if (converter.condition(schema, options)) {
+        return converter.convert(schema, options);
+      }
+    }
+    return [false, {}];
+  }
+}
+
+class OpenAPIGeneratorError extends Error {
+}
+class OpenAPIGenerator {
+  serializer;
+  converter;
+  constructor(options = {}) {
+    this.serializer = new StandardOpenAPIJsonSerializer(options);
+    this.converter = new CompositeSchemaConverter(toArray(options.schemaConverters));
+  }
+  async generate(router, base) {
+    const doc = clone(base);
+    doc.openapi = "3.1.1";
+    const errors = [];
+    await resolveContractProcedures({ path: [], router }, ({ contract, path }) => {
+      const operationId = 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)
+        };
+        this.#request(operationObjectRef, def);
+        this.#successResponse(operationObjectRef, def);
+        this.#errorResponse(operationObjectRef, def);
+        doc.paths ??= {};
+        doc.paths[httpPath] ??= {};
+        doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
+      } catch (e) {
+        if (!(e instanceof OpenAPIGeneratorError)) {
+          throw e;
+        }
+        errors.push(
+          `[OpenAPIGenerator] Error occurred while generating OpenAPI for procedure at path: ${operationId}
+${e.message}`
+        );
+      }
+    });
+    if (errors.length) {
+      throw new OpenAPIGeneratorError(
+        `Some error occurred during OpenAPI generation:
+
+${errors.join("\n\n")}`
+      );
+    }
+    return this.serializer.serialize(doc)[0];
+  }
+  #request(ref, def) {
+    const method = fallbackContractConfig("defaultMethod", def.route.method);
+    const details = getEventIteratorSchemaDetails(def.inputSchema);
+    if (details) {
+      ref.requestBody = {
+        required: true,
+        content: toOpenAPIEventIteratorContent(
+          this.converter.convert(details.yields, { strategy: "input" }),
+          this.converter.convert(details.returns, { strategy: "input" })
+        )
+      };
+      return;
+    }
+    const dynamicParams = getDynamicParams(def.route.path)?.map((v) => v.name);
+    const inputStructure = fallbackContractConfig("defaultInputStructure", def.route.inputStructure);
+    let [required, schema] = this.converter.convert(def.inputSchema, { strategy: "input" });
+    if (isAnySchema(schema) && !dynamicParams?.length) {
+      return;
+    }
+    if (inputStructure === "compact") {
+      if (dynamicParams?.length) {
+        const error2 = new OpenAPIGeneratorError(
+          'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
+        );
+        if (!isObjectSchema(schema)) {
+          throw error2;
+        }
+        const [paramsSchema, rest] = separateObjectSchema(schema, dynamicParams);
+        schema = rest;
+        required = rest.required ? rest.required.length !== 0 : false;
+        if (!checkParamsSchema(paramsSchema, dynamicParams)) {
+          throw error2;
+        }
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(paramsSchema, "path"));
+      }
+      if (method === "GET") {
+        if (!isObjectSchema(schema)) {
+          throw new OpenAPIGeneratorError(
+            'When method is "GET", input schema must satisfy: object | any | unknown'
+          );
+        }
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(schema, "query"));
+      } else {
+        ref.requestBody = {
+          required,
+          content: toOpenAPIContent(schema)
+        };
+      }
+      return;
+    }
+    const error = new OpenAPIGeneratorError(
+      'When input structure is "detailed", input schema must satisfy: { params?: Record<string, unknown>, query?: Record<string, unknown>, headers?: Record<string, unknown>, body?: unknown }'
+    );
+    if (!isObjectSchema(schema)) {
+      throw error;
+    }
+    if (dynamicParams?.length && (schema.properties?.params === void 0 || !isObjectSchema(schema.properties.params) || !checkParamsSchema(schema.properties.params, 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.'
+      );
+    }
+    for (const from of ["params", "query", "headers"]) {
+      const fromSchema = schema.properties?.[from];
+      if (fromSchema !== void 0) {
+        if (!isObjectSchema(fromSchema)) {
+          throw error;
+        }
+        const parameterIn = from === "params" ? "path" : from === "headers" ? "header" : "query";
+        ref.parameters ??= [];
+        ref.parameters.push(...toOpenAPIParameters(fromSchema, parameterIn));
+      }
+    }
+    if (schema.properties?.body !== void 0) {
+      ref.requestBody = {
+        required: schema.required?.includes("body"),
+        content: toOpenAPIContent(schema.properties.body)
+      };
+    }
+  }
+  #successResponse(ref, def) {
+    const outputSchema = def.outputSchema;
+    const status = fallbackContractConfig("defaultSuccessStatus", def.route.successStatus);
+    const description = fallbackContractConfig("defaultSuccessDescription", def.route?.successDescription);
+    const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(outputSchema);
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", def.route.outputStructure);
+    if (eventIteratorSchemaDetails) {
+      ref.responses ??= {};
+      ref.responses[status] = {
+        description,
+        content: toOpenAPIEventIteratorContent(
+          this.converter.convert(eventIteratorSchemaDetails.yields, { strategy: "output" }),
+          this.converter.convert(eventIteratorSchemaDetails.returns, { strategy: "output" })
+        )
+      };
+      return;
+    }
+    const [required, json] = this.converter.convert(outputSchema, { strategy: "output" });
+    ref.responses ??= {};
+    ref.responses[status] = {
+      description
+    };
+    if (outputStructure === "compact") {
+      ref.responses[status].content = toOpenAPIContent(applySchemaOptionality(required, json));
+      return;
+    }
+    const error = new OpenAPIGeneratorError(
+      'When output structure is "detailed", output schema must satisfy: { headers?: Record<string, unknown>, body?: unknown }'
+    );
+    if (!isObjectSchema(json)) {
+      throw error;
+    }
+    if (json.properties?.headers !== void 0) {
+      if (!isObjectSchema(json.properties.headers)) {
+        throw error;
+      }
+      for (const key in json.properties.headers.properties) {
+        ref.responses[status].headers ??= {};
+        ref.responses[status].headers[key] = {
+          schema: toOpenAPISchema(json.properties.headers.properties[key]),
+          required: json.properties.headers.required?.includes(key)
+        };
+      }
+    }
+    if (json.properties?.body !== void 0) {
+      ref.responses[status].content = toOpenAPIContent(
+        applySchemaOptionality(json.required?.includes("body") ?? false, json.properties.body)
+      );
+    }
+  }
+  #errorResponse(ref, def) {
+    const errorMap = def.errorMap;
+    const errors = {};
+    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] = this.converter.convert(config.data, { strategy: "output" });
+      errors[status] ??= [];
+      errors[status].push({
+        type: "object",
+        properties: {
+          defined: { const: true },
+          code: { const: code },
+          status: { const: status },
+          message: { type: "string", default: message },
+          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({
+          oneOf: [
+            ...schemas,
+            {
+              type: "object",
+              properties: {
+                defined: { const: false },
+                code: { type: "string" },
+                status: { type: "number" },
+                message: { type: "string" },
+                data: {}
+              },
+              required: ["defined", "code", "status", "message"]
+            }
+          ]
+        })
+      };
+    }
+  }
+}
+
+const oo = {
+  spec: customOpenAPIOperation
+};
+
+export { CompositeSchemaConverter, LOGIC_KEYWORDS, OpenAPIGenerator, applyCustomOpenAPIOperation, applySchemaOptionality, checkParamsSchema, customOpenAPIOperation, filterSchemaBranches, getCustomOpenAPIOperation, isAnySchema, isFileSchema, isObjectSchema, oo, separateObjectSchema, toOpenAPIContent, toOpenAPIEventIteratorContent, toOpenAPIMethod, toOpenAPIParameters, toOpenAPIPath, toOpenAPISchema };

package/dist/shared/openapi.CGZ7t-VN.mjs

@@ -0,0 +1,17 @@
+import { StandardOpenAPIJsonSerializer, StandardBracketNotationSerializer, StandardOpenAPISerializer } from '@orpc/openapi-client/standard';
+import { FetchHandler } from '@orpc/server/fetch';
+import { StandardHandler } from '@orpc/server/standard';
+import { a as StandardOpenAPIMatcher, S as StandardOpenAPICodec } from './openapi.sdeu0I7N.mjs';
+
+class OpenAPIHandler extends FetchHandler {
+  constructor(router, options = {}) {
+    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
+    const bracketNotationSerializer = new StandardBracketNotationSerializer();
+    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
+    const matcher = new StandardOpenAPIMatcher();
+    const codec = new StandardOpenAPICodec(serializer);
+    super(new StandardHandler(router, matcher, codec, options), options);
+  }
+}
+
+export { OpenAPIHandler as O };

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

@@ -0,0 +1,8 @@
+import { StandardOpenAPIJsonSerializerOptions } from '@orpc/openapi-client/standard';
+import { Context } from '@orpc/server';
+import { StandardHandlerOptions } from '@orpc/server/standard';
+
+interface StandardOpenAPIHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardOpenAPIJsonSerializerOptions {
+}
+
+export type { StandardOpenAPIHandlerOptions as S };

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

@@ -0,0 +1,8 @@
+import { StandardOpenAPIJsonSerializerOptions } from '@orpc/openapi-client/standard';
+import { Context } from '@orpc/server';
+import { StandardHandlerOptions } from '@orpc/server/standard';
+
+interface StandardOpenAPIHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, StandardOpenAPIJsonSerializerOptions {
+}
+
+export type { StandardOpenAPIHandlerOptions as S };

package/dist/{chunk-PGCWJMRO.js → shared/openapi.sdeu0I7N.mjs}

@@ -1,13 +1,12 @@
-import {
-  standardizeHTTPPath
-} from "./chunk-XGHV4TH3.js";
+import { fallbackContractConfig } from '@orpc/contract';
+import { isObject } 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';
+import { standardizeHTTPPath } from '@orpc/openapi-client/standard';
 
-// src/adapters/standard/openapi-codec.ts
-import { OpenAPISerializer } from "@orpc/client/openapi";
-import { fallbackContractConfig } from "@orpc/contract";
-import { isObject } from "@orpc/shared";
-var OpenAPICodec = class {
-  constructor(serializer = new OpenAPISerializer()) {
+class StandardOpenAPICodec {
+  constructor(serializer) {
     this.serializer = serializer;
   }
   async decode(request, params, procedure) {
@@ -67,25 +66,25 @@ var OpenAPICodec = class {
     return {
       status: error.status,
       headers: {},
-      body: this.serializer.serialize(error.toJSON())
+      body: this.serializer.serialize(error.toJSON(), { outputFormat: "plain" })
     };
   }
-};
+}
 
-// src/adapters/standard/openapi-matcher.ts
-import { fallbackContractConfig as fallbackContractConfig2 } from "@orpc/contract";
-import { convertPathToHttpPath, createContractedProcedure, eachContractProcedure, getLazyRouterPrefix, getRouterChild, isProcedure, unlazy } from "@orpc/server";
-import { addRoute, createRouter, findRoute } from "rou3";
-var OpenAPIMatcher = class {
+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)]));
+}
+
+class StandardOpenAPIMatcher {
   tree = createRouter();
   pendingRouters = [];
   init(router, path = []) {
-    const laziedOptions = eachContractProcedure({
-      router,
-      path
-    }, ({ path: path2, contract }) => {
-      const method = fallbackContractConfig2("defaultMethod", contract["~orpc"].route.method);
-      const httpPath = contract["~orpc"].route.path ? toRou3Pattern(contract["~orpc"].route.path) : convertPathToHttpPath(path2);
+    const laziedOptions = traverseContractProcedures({ router, path }, ({ path: path2, contract }) => {
+      const method = fallbackContractConfig("defaultMethod", contract["~orpc"].route.method);
+      const httpPath = toRou3Pattern(contract["~orpc"].route.path ?? toHttpPath(path2));
       if (isProcedure(contract)) {
         addRoute(this.tree, method, httpPath, {
           path: path2,
@@ -105,8 +104,8 @@ var OpenAPIMatcher = class {
     });
     this.pendingRouters.push(...laziedOptions.map((option) => ({
       ...option,
-      httpPathPrefix: convertPathToHttpPath(option.path),
-      laziedPrefix: getLazyRouterPrefix(option.lazied)
+      httpPathPrefix: toHttpPath(option.path),
+      laziedPrefix: getLazyMeta(option.router).prefix
     })));
   }
   async match(method, pathname) {
@@ -114,7 +113,7 @@ var OpenAPIMatcher = class {
       const newPendingRouters = [];
       for (const pendingRouter of this.pendingRouters) {
         if (!pendingRouter.laziedPrefix || pathname.startsWith(pendingRouter.laziedPrefix) || pathname.startsWith(pendingRouter.httpPathPrefix)) {
-          const { default: router } = await unlazy(pendingRouter.lazied);
+          const { default: router } = await unlazy(pendingRouter.router);
           this.init(router, pendingRouter.path);
         } else {
           newPendingRouters.push(pendingRouter);
@@ -127,14 +126,14 @@ var OpenAPIMatcher = class {
       return void 0;
     }
     if (!match.data.procedure) {
-      const { default: maybeProcedure } = await unlazy(getRouterChild(match.data.router, ...match.data.path));
+      const { default: maybeProcedure } = await unlazy(getRouter(match.data.router, match.data.path));
       if (!isProcedure(maybeProcedure)) {
         throw new Error(`
-          [Contract-First] Missing or invalid implementation for procedure at path: ${convertPathToHttpPath(match.data.path)}.
+          [Contract-First] Missing or invalid implementation for procedure at path: ${toHttpPath(match.data.path)}.
           Ensure that the procedure is correctly defined and matches the expected contract.
         `);
       }
-      match.data.procedure = createContractedProcedure(match.data.contract, maybeProcedure);
+      match.data.procedure = createContractedProcedure(maybeProcedure, match.data.contract);
     }
     return {
       path: match.data.path,
@@ -142,16 +141,6 @@ var OpenAPIMatcher = class {
       params: match.params ? decodeParams(match.params) : void 0
     };
   }
-};
-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)]));
 }
 
-export {
-  OpenAPICodec,
-  OpenAPIMatcher
-};
-//# sourceMappingURL=chunk-PGCWJMRO.js.map
+export { StandardOpenAPICodec as S, StandardOpenAPIMatcher as a, decodeParams as d, toRou3Pattern as t };