@orpc/openapi 0.11.0 → 0.13.0

package/dist/chunk-KZIT2WCV.js

@@ -0,0 +1,49 @@
+// src/utils.ts
+import { isContractProcedure } from "@orpc/contract";
+import { isLazy, isProcedure, ROUTER_CONTRACT_SYMBOL } from "@orpc/server";
+function eachContractProcedureLeaf(options, callback, result = [], isCurrentRouterContract = false) {
+  if (!isCurrentRouterContract && ROUTER_CONTRACT_SYMBOL in options.router && options.router[ROUTER_CONTRACT_SYMBOL]) {
+    return eachContractProcedureLeaf(
+      {
+        path: options.path,
+        router: options.router[ROUTER_CONTRACT_SYMBOL]
+      },
+      callback,
+      result,
+      true
+    );
+  }
+  if (isLazy(options.router)) {
+    result.push({
+      lazy: options.router,
+      path: options.path
+    });
+  } else if (isProcedure(options.router)) {
+    callback({
+      contract: options.router.zz$p.contract,
+      path: options.path
+    });
+  } else if (isContractProcedure(options.router)) {
+    callback({
+      contract: options.router,
+      path: options.path
+    });
+  } else {
+    for (const key in options.router) {
+      eachContractProcedureLeaf(
+        {
+          router: options.router[key],
+          path: [...options.path, key]
+        },
+        callback,
+        result
+      );
+    }
+  }
+  return result;
+}
+
+export {
+  eachContractProcedureLeaf
+};
+//# sourceMappingURL=chunk-KZIT2WCV.js.map

package/dist/fetch.js

@@ -0,0 +1,703 @@
+import {
+  eachContractProcedureLeaf
+} from "./chunk-KZIT2WCV.js";
+
+// src/fetch/base-handler.ts
+import { ORPC_HEADER, standardizeHTTPPath } from "@orpc/contract";
+import { createProcedureCaller, isLazy, isProcedure, LAZY_LOADER_SYMBOL, LAZY_ROUTER_PREFIX_SYMBOL, 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 = await resolveRouter(options.router, method, pathname);
+      if (!match) {
+        throw new ORPCError({ code: "NOT_FOUND", message: "Not found" });
+      }
+      const procedure = isLazy(match.procedure) ? (await match.procedure[LAZY_LOADER_SYMBOL]()).default : match.procedure;
+      const path = match.path;
+      if (!isProcedure(procedure)) {
+        throw new ORPCError({
+          code: "NOT_FOUND",
+          message: "Not found"
+        });
+      }
+      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();
+var pendingCache = /* @__PURE__ */ new Map();
+function createResolveRouter(createHonoRouter) {
+  const addRoutes = (routing, pending, options) => {
+    const lazies = eachContractProcedureLeaf(options, ({ path, contract }) => {
+      const method = contract.zz$cp.method ?? "POST";
+      const httpPath = contract.zz$cp.path ? openAPIPathToRouterPath(contract.zz$cp.path) : `/${path.map(encodeURIComponent).join("/")}`;
+      routing.add(method, httpPath, path);
+    });
+    pending.ref.push(...lazies);
+  };
+  return async (router, method, pathname) => {
+    const pending = (() => {
+      let pending2 = pendingCache.get(router);
+      if (!pending2) {
+        pending2 = { ref: [] };
+        pendingCache.set(router, pending2);
+      }
+      return pending2;
+    })();
+    const routing = (() => {
+      let routing2 = routingCache.get(router);
+      if (!routing2) {
+        routing2 = createHonoRouter();
+        routingCache.set(router, routing2);
+        addRoutes(routing2, pending, { router, path: [] });
+      }
+      return routing2;
+    })();
+    const newPending = [];
+    for (const item of pending.ref) {
+      if (LAZY_ROUTER_PREFIX_SYMBOL in item.lazy && item.lazy[LAZY_ROUTER_PREFIX_SYMBOL] && !pathname.startsWith(item.lazy[LAZY_ROUTER_PREFIX_SYMBOL]) && !pathname.startsWith(`/${item.path.map(encodeURIComponent).join("/")}`)) {
+        newPending.push(item);
+        continue;
+      }
+      const router2 = (await item.lazy[LAZY_LOADER_SYMBOL]()).default;
+      addRoutes(routing, pending, { path: item.path, router: router2 });
+    }
+    pending.ref = newPending;
+    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];
+    const params = params_ ? mapValues(
+      match[1],
+      (v) => params_[v]
+    ) : match[1];
+    let current = router;
+    for (const segment of path) {
+      if (typeof current !== "object" && typeof current !== "function" || !current) {
+        current = void 0;
+        break;
+      }
+      current = current[segment];
+    }
+    return isProcedure(current) || isLazy(current) ? {
+      path,
+      procedure: current,
+      params: { ...params }
+      // params from hono not a normal object, so we need spread here
+    } : void 0;
+  };
+}
+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
+};
+//# sourceMappingURL=fetch.js.map

package/dist/index.js

@@ -1,6 +1,10 @@
+import {
+  eachContractProcedureLeaf
+} from "./chunk-KZIT2WCV.js";
+
 // src/generator.ts
-import { eachContractRouterLeaf } from "@orpc/contract";
-import { toContractRouter } from "@orpc/server";
+import { isContractProcedure } from "@orpc/contract";
+import { LAZY_LOADER_SYMBOL } from "@orpc/server";
 import { findDeepMatches, isPlainObject, omit } from "@orpc/shared";
 import { preSerialize } from "@orpc/transformer";
 import {
@@ -4210,7 +4214,7 @@ function extractJSONSchema(schema, check, matches = []) {
 }
 
 // src/generator.ts
-function generateOpenAPI(opts, options) {
+async function generateOpenAPI(opts, options) {
   const throwOnMissingTagDefinition = options?.throwOnMissingTagDefinition ?? false;
   const ignoreUndefinedPathProcedures = options?.ignoreUndefinedPathProcedures ?? false;
   const builder = new OpenApiBuilder({
@@ -4218,197 +4222,212 @@ function generateOpenAPI(opts, options) {
     openapi: "3.1.0"
   });
   const rootTags = opts.tags?.map((tag) => tag.name) ?? [];
-  const router = toContractRouter(opts.router);
-  eachContractRouterLeaf(router, (procedure, path_) => {
-    const internal = procedure.zz$cp;
-    if (ignoreUndefinedPathProcedures && internal.path === void 0) {
-      return;
-    }
-    const path = internal.path ?? `/${path_.map(encodeURIComponent).join("/")}`;
-    const method = internal.method ?? "POST";
-    let inputSchema = internal.InputSchema ? zodToJsonSchema(internal.InputSchema, { mode: "input" }) : {};
-    const outputSchema = internal.OutputSchema ? zodToJsonSchema(internal.OutputSchema, { mode: "output" }) : {};
-    const params = (() => {
-      const names = path.match(/\{([^}]+)\}/g);
-      if (!names || !names.length) {
-        return void 0;
+  const pending = [{
+    path: [],
+    router: opts.router
+  }];
+  for (const item of pending) {
+    const lazies = eachContractProcedureLeaf(item, ({ contract, path }) => {
+      if (!isContractProcedure(contract)) {
+        return;
       }
-      if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
-        throw new Error(
-          `When path has parameters, input schema must be an object [${path_.join(".")}]`
-        );
+      const internal = contract.zz$cp;
+      if (ignoreUndefinedPathProcedures && internal.path === void 0) {
+        return;
       }
-      return names.map((raw) => raw.slice(1, -1)).map((name) => {
-        let schema = inputSchema.properties?.[name];
-        const required = inputSchema.required?.includes(name);
-        if (schema === void 0) {
-          throw new Error(
-            `Parameter ${name} is missing in input schema [${path_.join(".")}]`
-          );
+      const httpPath = internal.path ?? `/${path.map(encodeURIComponent).join("/")}`;
+      const method = internal.method ?? "POST";
+      let inputSchema = internal.InputSchema ? zodToJsonSchema(internal.InputSchema, { mode: "input" }) : {};
+      const outputSchema = internal.OutputSchema ? zodToJsonSchema(internal.OutputSchema, { mode: "output" }) : {};
+      const params = (() => {
+        const names = httpPath.match(/\{([^}]+)\}/g);
+        if (!names || !names.length) {
+          return void 0;
         }
-        if (!required) {
+        if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
           throw new Error(
-            `Parameter ${name} must be required in input schema [${path_.join(".")}]`
+            `When path has parameters, input schema must be an object [${path.join(".")}]`
           );
         }
-        const examples = inputSchema.examples?.filter((example) => {
-          return isPlainObject(example) && name in example;
-        }).map((example) => {
-          return example[name];
-        });
-        schema = {
-          examples: examples?.length ? examples : void 0,
-          ...schema === true ? {} : schema === false ? UNSUPPORTED_JSON_SCHEMA : schema
-        };
-        inputSchema = {
-          ...inputSchema,
-          properties: inputSchema.properties ? Object.entries(inputSchema.properties).reduce(
-            (acc, [key, value]) => {
-              if (key !== name) {
-                acc[key] = value;
-              }
-              return acc;
-            },
-            {}
-          ) : void 0,
-          required: inputSchema.required?.filter((v) => v !== name),
-          examples: inputSchema.examples?.map((example) => {
-            if (!isPlainObject(example))
-              return example;
-            return Object.entries(example).reduce(
-              (acc, [key, value]) => {
-                if (key !== name) {
-                  acc[key] = value;
-                }
-                return acc;
-              },
-              {}
+        return names.map((raw) => raw.slice(1, -1)).map((name) => {
+          let schema = inputSchema.properties?.[name];
+          const required = inputSchema.required?.includes(name);
+          if (schema === void 0) {
+            throw new Error(
+              `Parameter ${name} is missing in input schema [${path.join(".")}]`
             );
-          })
-        };
-        return {
-          name,
-          in: "path",
-          required: true,
-          schema,
-          example: internal.inputExample?.[name]
-        };
-      });
-    })();
-    const query = (() => {
-      if (method !== "GET" || Object.keys(inputSchema).length === 0) {
-        return void 0;
-      }
-      if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
-        throw new Error(
-          `When method is GET, input schema must be an object [${path_.join(".")}]`
-        );
-      }
-      return Object.entries(inputSchema.properties ?? {}).map(
-        ([name, schema]) => {
+          }
+          if (!required) {
+            throw new Error(
+              `Parameter ${name} must be required in input schema [${path.join(".")}]`
+            );
+          }
           const examples = inputSchema.examples?.filter((example) => {
             return isPlainObject(example) && name in example;
           }).map((example) => {
             return example[name];
           });
-          const schema_ = {
+          schema = {
             examples: examples?.length ? examples : void 0,
             ...schema === true ? {} : schema === false ? UNSUPPORTED_JSON_SCHEMA : schema
           };
+          inputSchema = {
+            ...inputSchema,
+            properties: inputSchema.properties ? Object.entries(inputSchema.properties).reduce(
+              (acc, [key, value]) => {
+                if (key !== name) {
+                  acc[key] = value;
+                }
+                return acc;
+              },
+              {}
+            ) : void 0,
+            required: inputSchema.required?.filter((v) => v !== name),
+            examples: inputSchema.examples?.map((example) => {
+              if (!isPlainObject(example))
+                return example;
+              return Object.entries(example).reduce(
+                (acc, [key, value]) => {
+                  if (key !== name) {
+                    acc[key] = value;
+                  }
+                  return acc;
+                },
+                {}
+              );
+            })
+          };
           return {
             name,
-            in: "query",
-            style: "deepObject",
-            required: inputSchema?.required?.includes(name) ?? false,
-            schema: schema_,
+            in: "path",
+            required: true,
+            schema,
             example: internal.inputExample?.[name]
           };
+        });
+      })();
+      const query = (() => {
+        if (method !== "GET" || Object.keys(inputSchema).length === 0) {
+          return void 0;
         }
-      );
-    })();
-    const parameters = [...params ?? [], ...query ?? []];
-    const requestBody = (() => {
-      if (method === "GET") {
-        return void 0;
-      }
-      const { schema, matches } = extractJSONSchema(inputSchema, isFileSchema);
-      const files = matches;
-      const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
-      if (files.length) {
-        parameters.push({
-          name: "content-disposition",
-          in: "header",
-          required: schema === void 0,
-          schema: {
-            type: "string",
-            pattern: "filename",
-            example: 'filename="file.png"',
-            description: "To define the file name. Required when the request body is a file."
+        if (typeof inputSchema !== "object" || inputSchema.type !== "object") {
+          throw new Error(
+            `When method is GET, input schema must be an object [${path.join(".")}]`
+          );
+        }
+        return Object.entries(inputSchema.properties ?? {}).map(
+          ([name, schema]) => {
+            const examples = inputSchema.examples?.filter((example) => {
+              return isPlainObject(example) && name in example;
+            }).map((example) => {
+              return example[name];
+            });
+            const schema_ = {
+              examples: examples?.length ? examples : void 0,
+              ...schema === true ? {} : schema === false ? UNSUPPORTED_JSON_SCHEMA : schema
+            };
+            return {
+              name,
+              in: "query",
+              style: "deepObject",
+              required: inputSchema?.required?.includes(name) ?? false,
+              schema: schema_,
+              example: internal.inputExample?.[name]
+            };
           }
-        });
-      }
-      const content = {};
-      for (const file of files) {
-        content[file.contentMediaType] = {
-          schema: file
-        };
-      }
-      if (schema !== void 0) {
-        content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
-          schema,
-          example: internal.inputExample
-        };
-      }
-      return {
-        required: Boolean(internal.InputSchema?.isOptional()),
-        content
-      };
-    })();
-    const successResponse = (() => {
-      const { schema, matches } = extractJSONSchema(outputSchema, isFileSchema);
-      const files = matches;
-      const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
-      const content = {};
-      for (const file of files) {
-        content[file.contentMediaType] = {
-          schema: file
+        );
+      })();
+      const parameters = [...params ?? [], ...query ?? []];
+      const requestBody = (() => {
+        if (method === "GET") {
+          return void 0;
+        }
+        const { schema, matches } = extractJSONSchema(inputSchema, isFileSchema);
+        const files = matches;
+        const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
+        if (files.length) {
+          parameters.push({
+            name: "content-disposition",
+            in: "header",
+            required: schema === void 0,
+            schema: {
+              type: "string",
+              pattern: "filename",
+              example: 'filename="file.png"',
+              description: "To define the file name. Required when the request body is a file."
+            }
+          });
+        }
+        const content = {};
+        for (const file of files) {
+          content[file.contentMediaType] = {
+            schema: file
+          };
+        }
+        if (schema !== void 0) {
+          content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
+            schema,
+            example: internal.inputExample
+          };
+        }
+        return {
+          required: Boolean(internal.InputSchema?.isOptional()),
+          content
         };
-      }
-      if (schema !== void 0) {
-        content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
-          schema,
-          example: internal.outputExample
+      })();
+      const successResponse = (() => {
+        const { schema, matches } = extractJSONSchema(outputSchema, isFileSchema);
+        const files = matches;
+        const isStillHasFileSchema = findDeepMatches(isFileSchema, schema).values.length > 0;
+        const content = {};
+        for (const file of files) {
+          content[file.contentMediaType] = {
+            schema: file
+          };
+        }
+        if (schema !== void 0) {
+          content[isStillHasFileSchema ? "multipart/form-data" : "application/json"] = {
+            schema,
+            example: internal.outputExample
+          };
+        }
+        return {
+          description: "OK",
+          content
         };
+      })();
+      if (throwOnMissingTagDefinition && internal.tags) {
+        const missingTag = internal.tags.find((tag) => !rootTags.includes(tag));
+        if (missingTag !== void 0) {
+          throw new Error(
+            `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path.join(".")}]`
+          );
+        }
       }
-      return {
-        description: "OK",
-        content
+      const operation = {
+        summary: internal.summary,
+        description: internal.description,
+        deprecated: internal.deprecated,
+        tags: internal.tags,
+        operationId: path.join("."),
+        parameters: parameters.length ? parameters : void 0,
+        requestBody,
+        responses: {
+          200: successResponse
+        }
       };
-    })();
-    if (throwOnMissingTagDefinition && internal.tags) {
-      const missingTag = internal.tags.find((tag) => !rootTags.includes(tag));
-      if (missingTag !== void 0) {
-        throw new Error(
-          `Tag "${missingTag}" is missing definition. Please define it in OpenAPI root tags object. [${path_.join(".")}]`
-        );
-      }
-    }
-    const operation = {
-      summary: internal.summary,
-      description: internal.description,
-      deprecated: internal.deprecated,
-      tags: internal.tags,
-      operationId: path_.join("."),
-      parameters: parameters.length ? parameters : void 0,
-      requestBody,
-      responses: {
-        200: successResponse
-      }
-    };
-    builder.addPath(path, {
-      [method.toLocaleLowerCase()]: operation
+      builder.addPath(httpPath, {
+        [method.toLocaleLowerCase()]: operation
+      });
     });
-  });
+    for (const lazy of lazies) {
+      const router = (await lazy.lazy[LAZY_LOADER_SYMBOL]()).default;
+      pending.push({
+        path: lazy.path,
+        router
+      });
+    }
+  }
   return preSerialize(builder.getSpec());
 }
 function isFileSchema(schema) {
@@ -4419,3 +4438,4 @@ function isFileSchema(schema) {
 export {
   generateOpenAPI
 };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,15 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Router } from '@orpc/server';
+import type { FetchHandler } from '@orpc/server/fetch';
+import type { Router as HonoRouter } from 'hono/router';
+export type ResolveRouter = (router: Router<any>, method: string, pathname: string) => Promise<{
+    path: string[];
+    procedure: ANY_PROCEDURE | ANY_LAZY_PROCEDURE;
+    params: Record<string, string>;
+} | undefined>;
+type Routing = HonoRouter<string[]>;
+export declare function createOpenAPIHandler(createHonoRouter: () => Routing): FetchHandler;
+export declare function createResolveRouter(createHonoRouter: () => Routing): ResolveRouter;
+export declare function openAPIPathToRouterPath(path: HTTPPath): string;
+export {};
+//# sourceMappingURL=base-handler.d.ts.map

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

@@ -0,0 +1,4 @@
+export * from './base-handler';
+export * from './server-handler';
+export * from './serverless-handler';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { FetchHandler } from '@orpc/server/fetch';
+export declare function createOpenAPIServerHandler(): FetchHandler;
+//# sourceMappingURL=server-handler.d.ts.map

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

@@ -0,0 +1,3 @@
+import type { FetchHandler } from '@orpc/server/fetch';
+export declare function createOpenAPIServerlessHandler(): FetchHandler;
+//# sourceMappingURL=serverless-handler.d.ts.map

package/dist/src/generator.d.ts

@@ -20,4 +20,5 @@ export interface GenerateOpenAPIOptions {
 }
 export declare function generateOpenAPI(opts: {
     router: ContractRouter | Router<any>;
-} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): OpenAPIObject;
+} & Omit<OpenAPIObject, 'openapi'>, options?: GenerateOpenAPIOptions): Promise<OpenAPIObject>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/src/index.d.ts

@@ -1,2 +1,3 @@
 /** unnoq */
 export * from './generator';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,16 @@
+import type { ContractProcedure, ContractRouter, WELL_CONTRACT_PROCEDURE } from '@orpc/contract';
+import type { ANY_LAZY_PROCEDURE, ANY_PROCEDURE, Lazy, Router } from '@orpc/server';
+export interface EachLeafOptions {
+    router: ANY_PROCEDURE | Router<any> | ContractRouter | ContractProcedure<any, any>;
+    path: string[];
+}
+export interface EachLeafCallbackOptions {
+    contract: WELL_CONTRACT_PROCEDURE;
+    path: string[];
+}
+export interface EachContractLeafResultItem {
+    lazy: ANY_LAZY_PROCEDURE | Lazy<Router<any>>;
+    path: string[];
+}
+export declare function eachContractProcedureLeaf(options: EachLeafOptions, callback: (options: EachLeafCallbackOptions) => void, result?: EachContractLeafResultItem[], isCurrentRouterContract?: boolean): EachContractLeafResultItem[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/zod-to-json-schema.d.ts

@@ -40,3 +40,4 @@ export declare function extractJSONSchema(schema: JSONSchema, check: (schema: JS
     schema: JSONSchema | undefined;
     matches: JSONSchema[];
 };
+//# sourceMappingURL=zod-to-json-schema.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,30 +19,37 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./fetch": {
+      "types": "./dist/src/fetch/index.d.ts",
+      "import": "./dist/fetch.js",
+      "default": "./dist/fetch.js"
+    },
     "./🔒/*": {
       "types": "./dist/src/*.d.ts"
     }
   },
   "files": [
-    "!dist/*.tsbuildinfo",
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
     "escape-string-regexp": "^5.0.0",
     "json-schema-typed": "^8.0.1",
     "openapi3-ts": "^4.4.0",
-    "@orpc/contract": "0.11.0",
-    "@orpc/server": "0.11.0",
-    "@orpc/shared": "0.11.0",
-    "@orpc/transformer": "0.11.0",
-    "@orpc/zod": "0.11.0"
+    "@orpc/contract": "0.13.0",
+    "@orpc/shared": "0.13.0",
+    "@orpc/server": "0.13.0",
+    "@orpc/transformer": "0.13.0",
+    "@orpc/zod": "0.13.0"
   },
   "devDependencies": {
     "@readme/openapi-parser": "^2.6.0",
+    "hono": "^4.6.12",
     "zod": "^3.23.8"
   },
   "scripts": {
-    "build": "tsup --clean --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --entry.fetch=src/fetch/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }