@orpc/openapi 0.0.0-next.55d0b4f → 0.0.0-next.56e31fa

package/dist/chunk-7HD5IZWG.js

@@ -0,0 +1,53 @@
+// 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;
+}
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+
+export {
+  eachContractProcedureLeaf,
+  standardizeHTTPPath
+};
+//# sourceMappingURL=chunk-7HD5IZWG.js.map

package/dist/fetch.js

@@ -1,12 +1,16 @@
+import {
+  eachContractProcedureLeaf,
+  standardizeHTTPPath
+} from "./chunk-7HD5IZWG.js";
+
 // 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 { createProcedureCaller, isLazy, isProcedure, LAZY_LOADER_SYMBOL, LAZY_ROUTER_PREFIX_SYMBOL, ORPCError } from "@orpc/server";
+import { executeWithHooks, isPlainObject, mapValues, ORPC_PROTOCOL_HEADER, ORPC_PROTOCOL_VALUE, 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) {
+    if (options.request.headers.get(ORPC_PROTOCOL_HEADER)?.includes(ORPC_PROTOCOL_VALUE)) {
       return void 0;
     }
     const context = await value(options.context);
@@ -17,14 +21,20 @@ function createOpenAPIHandler(createHonoRouter) {
       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);
+      const match = await resolveRouter(options.router, method, pathname);
       if (!match) {
         throw new ORPCError({ code: "NOT_FOUND", message: "Not found" });
       }
-      const procedure = match.procedure;
+      const procedure = isLazy(match.procedure) ? (await match.procedure[LAZY_LOADER_SYMBOL]()).default : match.procedure;
       const path = match.path;
-      const params = procedure.zz$p.contract.zz$cp.InputSchema ? zodCoerce(
-        procedure.zz$p.contract.zz$cp.InputSchema,
+      if (!isProcedure(procedure)) {
+        throw new ORPCError({
+          code: "NOT_FOUND",
+          message: "Not found"
+        });
+      }
+      const params = procedure.zz$p.contract["~orpc"].InputSchema ? zodCoerce(
+        procedure.zz$p.contract["~orpc"].InputSchema,
         match.params,
         { bracketNotation: true }
       ) : match.params;
@@ -35,7 +45,7 @@ function createOpenAPIHandler(createHonoRouter) {
         procedure,
         path
       });
-      const output = await caller(mergedInput);
+      const output = await caller(mergedInput, { signal: options.signal });
       const { body, headers } = serializer.serialize(output);
       return new Response(body, {
         status: 200,
@@ -43,10 +53,15 @@ function createOpenAPIHandler(createHonoRouter) {
       });
     };
     try {
-      return await options.hooks?.(context, {
-        next: handler,
-        response: (response) => response
-      }) ?? await handler();
+      return await executeWithHooks({
+        context,
+        hooks: options,
+        execute: handler,
+        input: options.request,
+        meta: {
+          signal: options.signal
+        }
+      });
     } catch (e) {
       const error = toORPCError(e);
       try {
@@ -69,27 +84,44 @@ function createOpenAPIHandler(createHonoRouter) {
   };
 }
 var routingCache = /* @__PURE__ */ new Map();
+var pendingCache = /* @__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 addRoutes = (routing, pending, options) => {
+    const lazies = eachContractProcedureLeaf(options, ({ path, contract }) => {
+      const method = contract["~orpc"].route?.method ?? "POST";
+      const httpPath = contract["~orpc"].route?.path ? openAPIPathToRouterPath(contract["~orpc"].route?.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;
@@ -97,18 +129,25 @@ function createResolveRouter(createHonoRouter) {
     if (!match) {
       return void 0;
     }
-    const path = match[0][0];
-    const procedure = match[0][1];
+    const path = match[0];
     const params = params_ ? mapValues(
       match[1],
       (v) => params_[v]
     ) : match[1];
-    return {
+    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,
+      procedure: current,
       params: { ...params }
       // params from hono not a normal object, so we need spread here
-    };
+    } : void 0;
   };
 }
 function mergeParamsAndInput(coercedParams, input) {
@@ -125,7 +164,7 @@ function mergeParamsAndInput(coercedParams, input) {
 }
 async function deserializeInput(request, procedure) {
   const deserializer = new OpenAPIDeserializer({
-    schema: procedure.zz$p.contract.zz$cp.InputSchema
+    schema: procedure.zz$p.contract["~orpc"].InputSchema
   });
   try {
     return await deserializer.deserialize(request);
@@ -148,13 +187,13 @@ function openAPIPathToRouterPath(path) {
   return standardizeHTTPPath(path).replace(/\{([^}]+)\}/g, ":$1");
 }
 
-// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router.js
+// ../../node_modules/.pnpm/hono@4.6.13/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
+// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/utils/url.js
 var checkOptionalParameter = (path) => {
   if (!path.match(/\:.+\?$/)) {
     return null;
@@ -183,7 +222,7 @@ var checkOptionalParameter = (path) => {
   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
+// ../../node_modules/.pnpm/hono@4.6.13/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 = "(?:|/.*)";
@@ -288,7 +327,7 @@ var Node = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/reg-exp-router/trie.js
+// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/reg-exp-router/trie.js
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
@@ -344,7 +383,7 @@ var Trie = class {
   }
 };
 
-// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/reg-exp-router/router.js
+// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/reg-exp-router/router.js
 var emptyParam = [];
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
@@ -545,7 +584,7 @@ function createOpenAPIServerHandler() {
   return createOpenAPIHandler(() => new RegExpRouter());
 }
 
-// ../../node_modules/.pnpm/hono@4.6.12/node_modules/hono/dist/router/linear-router/router.js
+// ../../node_modules/.pnpm/hono@4.6.13/node_modules/hono/dist/router/linear-router/router.js
 var emptyParams = /* @__PURE__ */ Object.create(null);
 var splitPathRe = /\/(:\w+(?:{(?:(?:{[\d,]+})|[^}])+})?)|\/[^\/\?]+|(\?)/g;
 var splitByStarRe = /\*/;
@@ -663,7 +702,6 @@ export {
   createOpenAPIHandler,
   createOpenAPIServerHandler,
   createOpenAPIServerlessHandler,
-  createResolveRouter,
-  openAPIPathToRouterPath
+  createResolveRouter
 };
 //# sourceMappingURL=fetch.js.map