@orpc/openapi 0.10.0 → 0.12.0

package/dist/fetch.js

@@ -0,0 +1,668 @@
+// src/fetch/base-handler.ts
+import { ORPC_HEADER, standardizeHTTPPath } from "@orpc/contract";
+import { createProcedureCaller, isProcedure, ORPCError } from "@orpc/server";
+import { isPlainObject, mapValues, trim, value } from "@orpc/shared";
+import { OpenAPIDeserializer, OpenAPISerializer, zodCoerce } from "@orpc/transformer";
+function createOpenAPIHandler(createHonoRouter) {
+  const resolveRouter = createResolveRouter(createHonoRouter);
+  return async (options) => {
+    if (options.request.headers.get(ORPC_HEADER) !== null) {
+      return void 0;
+    }
+    const context = await value(options.context);
+    const accept = options.request.headers.get("Accept") || void 0;
+    const serializer = new OpenAPISerializer({ accept });
+    const handler = async () => {
+      const url = new URL(options.request.url);
+      const pathname = `/${trim(url.pathname.replace(options.prefix ?? "", ""), "/")}`;
+      const customMethod = options.request.method === "POST" ? url.searchParams.get("method")?.toUpperCase() : void 0;
+      const method = customMethod || options.request.method;
+      const match = resolveRouter(options.router, method, pathname);
+      if (!match) {
+        throw new ORPCError({ code: "NOT_FOUND", message: "Not found" });
+      }
+      const procedure = match.procedure;
+      const path = match.path;
+      const params = procedure.zz$p.contract.zz$cp.InputSchema ? zodCoerce(
+        procedure.zz$p.contract.zz$cp.InputSchema,
+        match.params,
+        { bracketNotation: true }
+      ) : match.params;
+      const input = await deserializeInput(options.request, procedure);
+      const mergedInput = mergeParamsAndInput(params, input);
+      const caller = createProcedureCaller({
+        context,
+        procedure,
+        path
+      });
+      const output = await caller(mergedInput);
+      const { body, headers } = serializer.serialize(output);
+      return new Response(body, {
+        status: 200,
+        headers
+      });
+    };
+    try {
+      return await options.hooks?.(context, {
+        next: handler,
+        response: (response) => response
+      }) ?? await handler();
+    } catch (e) {
+      const error = toORPCError(e);
+      try {
+        const { body, headers } = serializer.serialize(error.toJSON());
+        return new Response(body, {
+          status: error.status,
+          headers
+        });
+      } catch (e2) {
+        const error2 = toORPCError(e2);
+        const { body, headers } = new OpenAPISerializer().serialize(
+          error2.toJSON()
+        );
+        return new Response(body, {
+          status: error2.status,
+          headers
+        });
+      }
+    }
+  };
+}
+var routingCache = /* @__PURE__ */ new Map();
+function createResolveRouter(createHonoRouter) {
+  return (router, method, pathname) => {
+    let routing = routingCache.get(router);
+    if (!routing) {
+      routing = createHonoRouter();
+      const addRouteRecursively = (routing2, router2, basePath) => {
+        for (const key in router2) {
+          const currentPath = [...basePath, key];
+          const item = router2[key];
+          if (isProcedure(item)) {
+            const method2 = item.zz$p.contract.zz$cp.method ?? "POST";
+            const path2 = item.zz$p.contract.zz$cp.path ? openAPIPathToRouterPath(item.zz$p.contract.zz$cp.path) : `/${currentPath.map(encodeURIComponent).join("/")}`;
+            routing2.add(method2, path2, [currentPath, item]);
+          } else {
+            addRouteRecursively(routing2, item, currentPath);
+          }
+        }
+      };
+      addRouteRecursively(routing, router, []);
+      routingCache.set(router, routing);
+    }
+    const [matches, params_] = routing.match(method, pathname);
+    const [match] = matches.sort((a, b) => {
+      return Object.keys(a[1]).length - Object.keys(b[1]).length;
+    });
+    if (!match) {
+      return void 0;
+    }
+    const path = match[0][0];
+    const procedure = match[0][1];
+    const params = params_ ? mapValues(
+      match[1],
+      (v) => params_[v]
+    ) : match[1];
+    return {
+      path,
+      procedure,
+      params: { ...params }
+      // params from hono not a normal object, so we need spread here
+    };
+  };
+}
+function mergeParamsAndInput(coercedParams, input) {
+  if (Object.keys(coercedParams).length === 0) {
+    return input;
+  }
+  if (!isPlainObject(input)) {
+    return coercedParams;
+  }
+  return {
+    ...coercedParams,
+    ...input
+  };
+}
+async function deserializeInput(request, procedure) {
+  const deserializer = new OpenAPIDeserializer({
+    schema: procedure.zz$p.contract.zz$cp.InputSchema
+  });
+  try {
+    return await deserializer.deserialize(request);
+  } catch (e) {
+    throw new ORPCError({
+      code: "BAD_REQUEST",
+      message: "Cannot parse request. Please check the request body and Content-Type header.",
+      cause: e
+    });
+  }
+}
+function toORPCError(e) {
+  return e instanceof ORPCError ? e : new ORPCError({
+    code: "INTERNAL_SERVER_ERROR",
+    message: "Internal server error",
+    cause: e
+  });
+}
+function openAPIPathToRouterPath(path) {
+  return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
+}
+
+// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router.js
+var METHOD_NAME_ALL = "ALL";
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/utils/url.js
+var checkOptionalParameter = (path) => {
+  if (!path.match(/\:.+\?$/)) {
+    return null;
+  }
+  const segments = path.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment)) {
+      basePath += "/" + segment;
+    } else if (/\:/.test(segment)) {
+      if (/\?/.test(segment)) {
+        if (results.length === 0 && basePath === "") {
+          results.push("/");
+        } else {
+          results.push(basePath);
+        }
+        const optionalSegment = segment.replace("?", "");
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else {
+        basePath += "/" + segment;
+      }
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+
+// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = Symbol();
+var regExpMetaChars = new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+    return 1;
+  } else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+    return -1;
+  }
+  if (a === LABEL_REG_EXP_STR) {
+    return 1;
+  } else if (b === LABEL_REG_EXP_STR) {
+    return -1;
+  }
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class {
+  #index;
+  #varIndex;
+  #children = /* @__PURE__ */ Object.create(null);
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
+    if (tokens.length === 0) {
+      if (this.#index !== void 0) {
+        throw PATH_ERROR;
+      }
+      if (pathErrorCheckOnly) {
+        return;
+      }
+      this.#index = index;
+      return;
+    }
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+    let node;
+    if (pattern) {
+      const name = pattern[1];
+      let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+      if (name && pattern[2]) {
+        regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+        if (/\((?!\?:)/.test(regexpStr)) {
+          throw PATH_ERROR;
+        }
+      }
+      node = this.#children[regexpStr];
+      if (!node) {
+        if (Object.keys(this.#children).some(
+          (k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[regexpStr] = new Node();
+        if (name !== "") {
+          node.#varIndex = context.varIndex++;
+        }
+      }
+      if (!pathErrorCheckOnly && name !== "") {
+        paramMap.push([name, node.#varIndex]);
+      }
+    } else {
+      node = this.#children[token];
+      if (!node) {
+        if (Object.keys(this.#children).some(
+          (k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR
+        )) {
+          throw PATH_ERROR;
+        }
+        if (pathErrorCheckOnly) {
+          return;
+        }
+        node = this.#children[token] = new Node();
+      }
+    }
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
+  }
+  buildRegExpStr() {
+    const childKeys = Object.keys(this.#children).sort(compareKey);
+    const strList = childKeys.map((k) => {
+      const c = this.#children[k];
+      return (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + c.buildRegExpStr();
+    });
+    if (typeof this.#index === "number") {
+      strList.unshift(`#${this.#index}`);
+    }
+    if (strList.length === 0) {
+      return "";
+    }
+    if (strList.length === 1) {
+      return strList[0];
+    }
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node();
+  insert(path, index, pathErrorCheckOnly) {
+    const paramAssoc = [];
+    const groups = [];
+    for (let i = 0; ; ) {
+      let replaced = false;
+      path = path.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced) {
+        break;
+      }
+    }
+    const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+      }
+    }
+    this.#root.insert(tokens, index, paramAssoc, this.#context, pathErrorCheckOnly);
+    return paramAssoc;
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "") {
+      return [/^$/, [], []];
+    }
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== void 0) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== void 0) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+  }
+};
+
+// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/reg-exp-router/router.js
+var emptyParam = [];
+var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
+var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+function buildWildcardRegExp(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(
+    path === "*" ? "" : `^${path.replace(
+      /\/\*$|([.\\+*[^\]$()])/g,
+      (_, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
+    )}$`
+  );
+}
+function clearWildcardRegExpCache() {
+  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+  const trie = new Trie();
+  const handlerData = [];
+  if (routes.length === 0) {
+    return nullMatcher;
+  }
+  const routesWithStaticPathFlag = routes.map(
+    (route) => [!/\*|\/:/.test(route[0]), ...route]
+  ).sort(
+    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
+  );
+  const staticMap = /* @__PURE__ */ Object.create(null);
+  for (let i = 0, j = -1, len = routesWithStaticPathFlag.length; i < len; i++) {
+    const [pathErrorCheckOnly, path, handlers] = routesWithStaticPathFlag[i];
+    if (pathErrorCheckOnly) {
+      staticMap[path] = [handlers.map(([h]) => [h, /* @__PURE__ */ Object.create(null)]), emptyParam];
+    } else {
+      j++;
+    }
+    let paramAssoc;
+    try {
+      paramAssoc = trie.insert(path, j, pathErrorCheckOnly);
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
+    if (pathErrorCheckOnly) {
+      continue;
+    }
+    handlerData[j] = handlers.map(([h, paramCount]) => {
+      const paramIndexMap = /* @__PURE__ */ Object.create(null);
+      paramCount -= 1;
+      for (; paramCount >= 0; paramCount--) {
+        const [key, value2] = paramAssoc[paramCount];
+        paramIndexMap[key] = value2;
+      }
+      return [h, paramIndexMap];
+    });
+  }
+  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+  for (let i = 0, len = handlerData.length; i < len; i++) {
+    for (let j = 0, len2 = handlerData[i].length; j < len2; j++) {
+      const map = handlerData[i][j]?.[1];
+      if (!map) {
+        continue;
+      }
+      const keys = Object.keys(map);
+      for (let k = 0, len3 = keys.length; k < len3; k++) {
+        map[keys[k]] = paramReplacementMap[map[keys[k]]];
+      }
+    }
+  }
+  const handlerMap = [];
+  for (const i in indexReplacementMap) {
+    handlerMap[i] = handlerData[indexReplacementMap[i]];
+  }
+  return [regexp, handlerMap, staticMap];
+}
+function findMiddleware(middleware, path) {
+  if (!middleware) {
+    return void 0;
+  }
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]];
+    }
+  }
+  return void 0;
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+    this.#routes = { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) };
+  }
+  add(method, path, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    if (!middleware || !routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    }
+    if (!middleware[method]) {
+      ;
+      [middleware, routes].forEach((handlerMap) => {
+        handlerMap[method] = /* @__PURE__ */ Object.create(null);
+        Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p) => {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]];
+        });
+      });
+    }
+    if (path === "/*") {
+      path = "*";
+    }
+    const paramCount = (path.match(/\/:/g) || []).length;
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      if (method === METHOD_NAME_ALL) {
+        Object.keys(middleware).forEach((m) => {
+          middleware[m][path] ||= findMiddleware(middleware[m], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+        });
+      } else {
+        middleware[method][path] ||= findMiddleware(middleware[method], path) || findMiddleware(middleware[METHOD_NAME_ALL], path) || [];
+      }
+      Object.keys(middleware).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(middleware[m]).forEach((p) => {
+            re.test(p) && middleware[m][p].push([handler, paramCount]);
+          });
+        }
+      });
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          Object.keys(routes[m]).forEach(
+            (p) => re.test(p) && routes[m][p].push([handler, paramCount])
+          );
+        }
+      });
+      return;
+    }
+    const paths = checkOptionalParameter(path) || [path];
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const path2 = paths[i];
+      Object.keys(routes).forEach((m) => {
+        if (method === METHOD_NAME_ALL || method === m) {
+          routes[m][path2] ||= [
+            ...findMiddleware(middleware[m], path2) || findMiddleware(middleware[METHOD_NAME_ALL], path2) || []
+          ];
+          routes[m][path2].push([handler, paramCount - len + i + 1]);
+        }
+      });
+    }
+  }
+  match(method, path) {
+    clearWildcardRegExpCache();
+    const matchers = this.#buildAllMatchers();
+    this.match = (method2, path2) => {
+      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+      const staticMatch = matcher[2][path2];
+      if (staticMatch) {
+        return staticMatch;
+      }
+      const match = path2.match(matcher[0]);
+      if (!match) {
+        return [[], emptyParam];
+      }
+      const index = match.indexOf("", 1);
+      return [matcher[1][index], match];
+    };
+    return this.match(method, path);
+  }
+  #buildAllMatchers() {
+    const matchers = /* @__PURE__ */ Object.create(null);
+    Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
+      matchers[method] ||= this.#buildMatcher(method);
+    });
+    this.#middleware = this.#routes = void 0;
+    return matchers;
+  }
+  #buildMatcher(method) {
+    const routes = [];
+    let hasOwnRoute = method === METHOD_NAME_ALL;
+    [this.#middleware, this.#routes].forEach((r) => {
+      const ownRoute = r[method] ? Object.keys(r[method]).map((path) => [path, r[method][path]]) : [];
+      if (ownRoute.length !== 0) {
+        hasOwnRoute ||= true;
+        routes.push(...ownRoute);
+      } else if (method !== METHOD_NAME_ALL) {
+        routes.push(
+          ...Object.keys(r[METHOD_NAME_ALL]).map((path) => [path, r[METHOD_NAME_ALL][path]])
+        );
+      }
+    });
+    if (!hasOwnRoute) {
+      return null;
+    } else {
+      return buildMatcherFromPreprocessedRoutes(routes);
+    }
+  }
+};
+
+// src/fetch/server-handler.ts
+function createOpenAPIServerHandler() {
+  return createOpenAPIHandler(() => new RegExpRouter());
+}
+
+// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/linear-router/router.js
+var emptyParams = /* @__PURE__ */ Object.create(null);
+var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
+var splitByStarRe = /\*/;
+var LinearRouter = class {
+  name = "LinearRouter";
+  #routes = [];
+  add(method, path, handler) {
+    for (let i = 0, paths = checkOptionalParameter(path) || [path], len = paths.length; i < len; i++) {
+      this.#routes.push([method, paths[i], handler]);
+    }
+  }
+  match(method, path) {
+    const handlers = [];
+    ROUTES_LOOP:
+      for (let i = 0, len = this.#routes.length; i < len; i++) {
+        const [routeMethod, routePath, handler] = this.#routes[i];
+        if (routeMethod === method || routeMethod === METHOD_NAME_ALL) {
+          if (routePath === "*" || routePath === "/*") {
+            handlers.push([handler, emptyParams]);
+            continue;
+          }
+          const hasStar = routePath.indexOf("*") !== -1;
+          const hasLabel = routePath.indexOf(":") !== -1;
+          if (!hasStar && !hasLabel) {
+            if (routePath === path || routePath + "/" === path) {
+              handlers.push([handler, emptyParams]);
+            }
+          } else if (hasStar && !hasLabel) {
+            const endsWithStar = routePath.charCodeAt(routePath.length - 1) === 42;
+            const parts = (endsWithStar ? routePath.slice(0, -2) : routePath).split(splitByStarRe);
+            const lastIndex = parts.length - 1;
+            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+              const part = parts[j];
+              const index = path.indexOf(part, pos);
+              if (index !== pos) {
+                continue ROUTES_LOOP;
+              }
+              pos += part.length;
+              if (j === lastIndex) {
+                if (!endsWithStar && pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+                  continue ROUTES_LOOP;
+                }
+              } else {
+                const index2 = path.indexOf("/", pos);
+                if (index2 === -1) {
+                  continue ROUTES_LOOP;
+                }
+                pos = index2;
+              }
+            }
+            handlers.push([handler, emptyParams]);
+          } else if (hasLabel && !hasStar) {
+            const params = /* @__PURE__ */ Object.create(null);
+            const parts = routePath.match(splitPathRe);
+            const lastIndex = parts.length - 1;
+            for (let j = 0, pos = 0, len2 = parts.length; j < len2; j++) {
+              if (pos === -1 || pos >= path.length) {
+                continue ROUTES_LOOP;
+              }
+              const part = parts[j];
+              if (part.charCodeAt(1) === 58) {
+                let name = part.slice(2);
+                let value2;
+                if (name.charCodeAt(name.length - 1) === 125) {
+                  const openBracePos = name.indexOf("{");
+                  const pattern = name.slice(openBracePos + 1, -1);
+                  const restPath = path.slice(pos + 1);
+                  const match = new RegExp(pattern, "d").exec(restPath);
+                  if (!match || match.indices[0][0] !== 0 || match.indices[0][1] === 0) {
+                    continue ROUTES_LOOP;
+                  }
+                  name = name.slice(0, openBracePos);
+                  value2 = restPath.slice(...match.indices[0]);
+                  pos += match.indices[0][1] + 1;
+                } else {
+                  let endValuePos = path.indexOf("/", pos + 1);
+                  if (endValuePos === -1) {
+                    if (pos + 1 === path.length) {
+                      continue ROUTES_LOOP;
+                    }
+                    endValuePos = path.length;
+                  }
+                  value2 = path.slice(pos + 1, endValuePos);
+                  pos = endValuePos;
+                }
+                params[name] ||= value2;
+              } else {
+                const index = path.indexOf(part, pos);
+                if (index !== pos) {
+                  continue ROUTES_LOOP;
+                }
+                pos += part.length;
+              }
+              if (j === lastIndex) {
+                if (pos !== path.length && !(pos === path.length - 1 && path.charCodeAt(pos) === 47)) {
+                  continue ROUTES_LOOP;
+                }
+              }
+            }
+            handlers.push([handler, params]);
+          } else if (hasLabel && hasStar) {
+            throw new UnsupportedPathError();
+          }
+        }
+      }
+    return [handlers];
+  }
+};
+
+// src/fetch/serverless-handler.ts
+function createOpenAPIServerlessHandler() {
+  return createOpenAPIHandler(() => new LinearRouter());
+}
+export {
+  createOpenAPIHandler,
+  createOpenAPIServerHandler,
+  createOpenAPIServerlessHandler,
+  createResolveRouter,
+  openAPIPathToRouterPath
+};

package/dist/index.js

@@ -4419,4 +4419,3 @@ function isFileSchema(schema) {
 export {
   generateOpenAPI
 };
-//# sourceMappingURL=index.js.map

package/dist/src/fetch/base-handler.d.ts

@@ -0,0 +1,14 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { FetchHandler } from '@orpc/server/fetch';
+import type { Router as HonoRouter } from 'hono/router';
+import { type Procedure, type Router } from '@orpc/server';
+export type ResolveRouter = (router: Router<any>, method: string, pathname: string) => {
+    path: string[];
+    procedure: Procedure<any, any, any, any, any>;
+    params: Record<string, string>;
+} | undefined;
+type Routing = HonoRouter<[string[], Procedure<any, any, any, any, any>]>;
+export declare function createOpenAPIHandler(createHonoRouter: () => Routing): FetchHandler;
+export declare function createResolveRouter(createHonoRouter: () => Routing): ResolveRouter;
+export declare function openAPIPathToRouterPath(path: HTTPPath): string;
+export {};

package/dist/src/fetch/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base-handler';
+export * from './server-handler';
+export * from './serverless-handler';

package/dist/src/fetch/server-handler.d.ts

@@ -0,0 +1,2 @@
+import type { FetchHandler } from '@orpc/server/fetch';
+export declare function createOpenAPIServerHandler(): FetchHandler;

package/dist/src/fetch/serverless-handler.d.ts

@@ -0,0 +1,2 @@
+import type { FetchHandler } from '@orpc/server/fetch';
+export declare function createOpenAPIServerlessHandler(): FetchHandler;