@orpc/server 0.0.0-next.e9dc36e → 0.0.0-next.ee0aeaf

package/dist/chunk-VARUID7X.js

@@ -0,0 +1,273 @@
+// src/utils.ts
+function mergeContext(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  return {
+    ...a,
+    ...b
+  };
+}
+
+// src/middleware.ts
+var decoratedMiddlewareSymbol = Symbol("\u{1F512}decoratedMiddleware");
+function decorateMiddleware(middleware) {
+  if (Reflect.get(middleware, decoratedMiddlewareSymbol)) {
+    return middleware;
+  }
+  const concat = (concatMiddleware, mapInput2) => {
+    const concatMiddleware_ = mapInput2 ? decorateMiddleware(concatMiddleware).mapInput(mapInput2) : concatMiddleware;
+    return decorateMiddleware(async (input, context, meta, ...rest) => {
+      const input_ = input;
+      const context_ = context;
+      const meta_ = meta;
+      const next = async (options) => {
+        return concatMiddleware_(input_, mergeContext(context_, options.context), meta_, ...rest);
+      };
+      const m1 = await middleware(input_, context_, {
+        ...meta_,
+        next
+      }, ...rest);
+      return m1;
+    });
+  };
+  const mapInput = (map) => {
+    return decorateMiddleware(
+      (input, ...rest) => middleware(map(input), ...rest)
+    );
+  };
+  return Object.assign(middleware, {
+    [decoratedMiddlewareSymbol]: true,
+    concat,
+    mapInput
+  });
+}
+
+// src/procedure-caller.ts
+import { executeWithHooks, trim, value } from "@orpc/shared";
+import { ORPCError } from "@orpc/shared/error";
+
+// 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 caller = async (...args) => {
+    const [input, callerOptions] = args;
+    const path = options.path ?? [];
+    const procedure = await loadProcedure(options.procedure);
+    const context = await value(options.context);
+    const execute = async () => {
+      const validInput = await (async () => {
+        const schema = procedure.zz$p.contract["~orpc"].InputSchema;
+        if (!schema) {
+          return input;
+        }
+        const result = await schema["~standard"].validate(input);
+        if (result.issues) {
+          throw new ORPCError({
+            message: "Validation input failed",
+            code: "BAD_REQUEST",
+            issues: result.issues
+          });
+        }
+        return result.value;
+      })();
+      const meta = {
+        path,
+        procedure,
+        signal: callerOptions?.signal
+      };
+      const middlewares = procedure.zz$p.middlewares ?? [];
+      let currentMidIndex = 0;
+      let currentContext = context;
+      const next = async (nextOptions) => {
+        const mid = middlewares[currentMidIndex];
+        currentMidIndex += 1;
+        currentContext = mergeContext(currentContext, nextOptions.context);
+        if (mid) {
+          return await mid(validInput, currentContext, {
+            ...meta,
+            next,
+            output: (output3) => ({ output: output3, context: void 0 })
+          });
+        } else {
+          return {
+            output: await await procedure.zz$p.func(validInput, currentContext, meta),
+            context: currentContext
+          };
+        }
+      };
+      const output2 = (await next({})).output;
+      const validOutput = await (async () => {
+        const schema = procedure.zz$p.contract["~orpc"].OutputSchema;
+        if (!schema) {
+          return output2;
+        }
+        const result = await schema["~standard"].validate(output2);
+        if (result.issues) {
+          throw new ORPCError({
+            message: "Validation output failed",
+            code: "INTERNAL_SERVER_ERROR"
+          });
+        }
+        return result.value;
+      })();
+      return validOutput;
+    };
+    const output = await executeWithHooks({
+      hooks: options,
+      input,
+      context,
+      meta: {
+        path,
+        procedure
+      },
+      execute
+    });
+    return output;
+  };
+  return caller;
+}
+async function loadProcedure(procedure) {
+  let loadedProcedure;
+  if (isLazy(procedure)) {
+    loadedProcedure = (await loadLazy(procedure)).default;
+  } else {
+    loadedProcedure = procedure;
+  }
+  if (!isProcedure(loadedProcedure)) {
+    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 loadedProcedure;
+}
+
+// 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
+  });
+  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] };
+      }));
+    }
+  });
+  return recursive;
+}
+
+export {
+  mergeContext,
+  decorateMiddleware,
+  LAZY_LOADER_SYMBOL,
+  createLazy,
+  loadLazy,
+  isLazy,
+  createFlattenLazy,
+  decorateLazy,
+  createProcedureCaller,
+  loadProcedure,
+  Procedure,
+  decorateProcedure,
+  isProcedure
+};
+//# sourceMappingURL=chunk-VARUID7X.js.map