@orpc/server 0.11.0 → 0.13.0

package/dist/{chunk-CVLK2PBB.js → chunk-FL4ZAGNE.js}

@@ -45,13 +45,92 @@ function decorateMiddleware(middleware) {
 }
 
 // src/procedure-caller.ts
-import { value } from "@orpc/shared";
+import { trim, value } from "@orpc/shared";
 import { ORPCError } from "@orpc/shared/error";
 import { OpenAPIDeserializer } from "@orpc/transformer";
+
+// src/procedure.ts
+import {
+  DecoratedContractProcedure,
+  isContractProcedure
+} from "@orpc/contract";
+var Procedure = class {
+  constructor(zz$p) {
+    this.zz$p = zz$p;
+  }
+};
+var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
+function decorateProcedure(procedure) {
+  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
+    return procedure;
+  }
+  return Object.assign(createProcedureCaller({
+    procedure,
+    context: void 0
+  }), {
+    [DECORATED_PROCEDURE_SYMBOL]: true,
+    zz$p: procedure.zz$p,
+    prefix(prefix) {
+      return decorateProcedure({
+        zz$p: {
+          ...procedure.zz$p,
+          contract: DecoratedContractProcedure.decorate(
+            procedure.zz$p.contract
+          ).prefix(prefix)
+        }
+      });
+    },
+    route(opts) {
+      return decorateProcedure({
+        zz$p: {
+          ...procedure.zz$p,
+          contract: DecoratedContractProcedure.decorate(
+            procedure.zz$p.contract
+          ).route(opts)
+        }
+      });
+    },
+    use(middleware, mapInput) {
+      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
+      return decorateProcedure({
+        zz$p: {
+          ...procedure.zz$p,
+          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
+        }
+      });
+    }
+  });
+}
+function isProcedure(item) {
+  if (item instanceof Procedure)
+    return true;
+  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
+}
+
+// src/procedure-caller.ts
 function createProcedureCaller(options) {
-  const path = options.path ?? [];
-  const procedure = options.procedure;
+  const loadProcedure = async () => {
+    let procedure;
+    if (isLazy(options.procedure)) {
+      procedure = (await loadLazy(options.procedure)).default;
+    } else {
+      procedure = options.procedure;
+    }
+    if (!isProcedure(procedure)) {
+      throw new ORPCError({
+        code: "NOT_FOUND",
+        message: "Not found",
+        cause: new Error(trim(`
+          This error should be caught by the typescript compiler.
+          But if you still see this error, it means that you trying to call a lazy router (expected to be a lazy procedure).
+        `))
+      });
+    }
+    return procedure;
+  };
   const caller = async (input) => {
+    const path = options.path ?? [];
+    const procedure = await loadProcedure();
     const input_ = (() => {
       if (!(input instanceof FormData)) {
         return input;
@@ -121,69 +200,68 @@ function createProcedureCaller(options) {
   return caller;
 }
 
-// src/procedure.ts
-import {
-  DecoratedContractProcedure,
-  isContractProcedure
-} from "@orpc/contract";
-var Procedure = class {
-  constructor(zz$p) {
-    this.zz$p = zz$p;
-  }
-};
-var DECORATED_PROCEDURE_SYMBOL = Symbol("DECORATED_PROCEDURE");
-function decorateProcedure(procedure) {
-  if (DECORATED_PROCEDURE_SYMBOL in procedure) {
-    return procedure;
-  }
-  return Object.assign(createProcedureCaller({
-    procedure,
+// src/lazy.ts
+var LAZY_LOADER_SYMBOL = Symbol("ORPC_LAZY_LOADER");
+function createLazy(loader) {
+  return {
+    [LAZY_LOADER_SYMBOL]: loader
+  };
+}
+function loadLazy(lazy) {
+  return lazy[LAZY_LOADER_SYMBOL]();
+}
+function isLazy(item) {
+  return (typeof item === "object" || typeof item === "function") && item !== null && LAZY_LOADER_SYMBOL in item && typeof item[LAZY_LOADER_SYMBOL] === "function";
+}
+function createFlattenLazy(lazy) {
+  const flattenLoader = async () => {
+    let current = await loadLazy(lazy);
+    while (true) {
+      if (!isLazy(current.default)) {
+        break;
+      }
+      current = await loadLazy(current.default);
+    }
+    return current;
+  };
+  const flattenLazy = {
+    [LAZY_LOADER_SYMBOL]: flattenLoader
+  };
+  return flattenLazy;
+}
+function decorateLazy(lazy) {
+  const flattenLazy = createFlattenLazy(lazy);
+  const procedureCaller = createProcedureCaller({
+    procedure: flattenLazy,
     context: void 0
-  }), {
-    [DECORATED_PROCEDURE_SYMBOL]: true,
-    zz$p: procedure.zz$p,
-    prefix(prefix) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).prefix(prefix)
-        }
-      });
-    },
-    route(opts) {
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          contract: DecoratedContractProcedure.decorate(
-            procedure.zz$p.contract
-          ).route(opts)
-        }
-      });
-    },
-    use(middleware, mapInput) {
-      const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-      return decorateProcedure({
-        zz$p: {
-          ...procedure.zz$p,
-          middlewares: [middleware_, ...procedure.zz$p.middlewares ?? []]
-        }
-      });
+  });
+  Object.assign(procedureCaller, flattenLazy);
+  const recursive = new Proxy(procedureCaller, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      return decorateLazy(createLazy(async () => {
+        const current = await loadLazy(flattenLazy);
+        return { default: current.default[key] };
+      }));
     }
   });
-}
-function isProcedure(item) {
-  if (item instanceof Procedure)
-    return true;
-  return (typeof item === "object" || typeof item === "function") && item !== null && "zz$p" in item && typeof item.zz$p === "object" && item.zz$p !== null && "contract" in item.zz$p && isContractProcedure(item.zz$p.contract) && "func" in item.zz$p && typeof item.zz$p.func === "function";
+  return recursive;
 }
 
 export {
   mergeContext,
   decorateMiddleware,
+  LAZY_LOADER_SYMBOL,
+  createLazy,
+  loadLazy,
+  isLazy,
+  createFlattenLazy,
+  decorateLazy,
   createProcedureCaller,
   Procedure,
   decorateProcedure,
   isProcedure
 };
+//# sourceMappingURL=chunk-FL4ZAGNE.js.map