effect-orpc 1.0.0-effect-v4.2 → 1.0.0-effect-v4.4

package/dist/index.js

@@ -1,15 +1,13 @@
 import {
   getCurrentServices
-} from "./chunk-E5YLLTJI.js";
+} from "./chunk-I5EWBI42.js";
+
+// src/contract.ts
+import { isContractProcedure as isContractProcedure2 } from "@orpc/contract";
+import { implement } from "@orpc/server";
 
 // src/effect-builder.ts
-import {
-  mergeMeta as mergeMeta2,
-  mergePrefix as mergePrefix2,
-  mergeRoute as mergeRoute2,
-  mergeTags,
-  ORPCError as ORPCError2
-} from "@orpc/contract";
+import { mergeMeta as mergeMeta2, mergePrefix as mergePrefix2, mergeRoute as mergeRoute2, mergeTags } from "@orpc/contract";
 import {
   addMiddleware as addMiddleware2,
   Builder,
@@ -17,7 +15,6 @@ import {
   fallbackConfig,
   lazy as lazy2
 } from "@orpc/server";
-import { Cause as Cause2, Effect, Exit, ServiceMap } from "effect";
 
 // src/effect-enhance-router.ts
 import {
@@ -323,6 +320,89 @@ function enhanceEffectRouter(router, options) {
   return enhanced;
 }
 
+// src/effect-runtime.ts
+import { ORPCError as ORPCError2 } from "@orpc/contract";
+import { Cause as Cause2, Effect, Exit, Result, Context } from "effect";
+function toORPCErrorFromCause(cause) {
+  if (Cause2.hasFails(cause)) {
+    const reason = Cause2.findFail(cause);
+    if (Result.isFailure(reason)) {
+      return new ORPCError2("INTERNAL_SERVER_ERROR");
+    }
+    const error = reason.success.error;
+    if (isORPCTaggedError(error)) {
+      return error.toORPCError();
+    }
+    if (error instanceof ORPCError2) {
+      return error;
+    }
+    return new ORPCError2("INTERNAL_SERVER_ERROR", {
+      cause: error
+    });
+  }
+  if (Cause2.hasDies(cause)) {
+    const reason = Cause2.findDie(cause);
+    if (Result.isFailure(reason)) {
+      return new ORPCError2("INTERNAL_SERVER_ERROR", {
+        cause: new Error(`Died by unknown reason`)
+      });
+    }
+    return new ORPCError2("INTERNAL_SERVER_ERROR", {
+      cause: reason.success.defect
+    });
+  }
+  if (Cause2.hasInterrupts(cause)) {
+    const reason = Cause2.findInterrupt(cause);
+    if (Result.isFailure(reason)) {
+      return new ORPCError2("INTERNAL_SERVER_ERROR", {
+        cause: new Error(`Unknown fiber got interrupted`)
+      });
+    }
+    return new ORPCError2("INTERNAL_SERVER_ERROR", {
+      cause: new Error(`${reason.success.fiberId} got interrupted`)
+    });
+  }
+  return new ORPCError2("INTERNAL_SERVER_ERROR");
+}
+function createEffectProcedureHandler(options) {
+  const {
+    runtime,
+    effectErrorMap,
+    effectFn,
+    spanConfig,
+    defaultCaptureStackTrace
+  } = options;
+  return async (opts) => {
+    const effectOpts = {
+      context: opts.context,
+      input: opts.input,
+      path: opts.path,
+      procedure: opts.procedure,
+      signal: opts.signal,
+      lastEventId: opts.lastEventId,
+      errors: createEffectErrorConstructorMap(effectErrorMap)
+    };
+    const spanName = spanConfig?.name ?? opts.path.join(".");
+    const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
+    const resolver = Effect.fnUntraced(effectFn);
+    const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
+      captureStackTrace
+    });
+    const parentServices = getCurrentServices();
+    const exit = parentServices ? await Effect.runPromiseExitWith(
+      Context.merge(await runtime.context(), parentServices)
+    )(tracedEffect, {
+      signal: opts.signal
+    }) : await runtime.runPromiseExit(tracedEffect, {
+      signal: opts.signal
+    });
+    if (Exit.isFailure(exit)) {
+      throw toORPCErrorFromCause(exit.cause);
+    }
+    return exit.value;
+  };
+}
+
 // src/effect-builder.ts
 function addSpanStackTrace() {
   const ErrorConstructor = Error;
@@ -344,32 +424,6 @@ function addSpanStackTrace() {
     }
   };
 }
-function toORPCErrorFromCause(cause) {
-  const reason = cause.reasons[0];
-  if (reason === void 0) {
-    return new ORPCError2("INTERNAL_SERVER_ERROR");
-  }
-  if (Cause2.isDieReason(reason)) {
-    return new ORPCError2("INTERNAL_SERVER_ERROR", {
-      cause: reason.defect
-    });
-  }
-  if (Cause2.isFailReason(reason)) {
-    const error = reason.error;
-    if (isORPCTaggedError(error)) {
-      return error.toORPCError();
-    }
-    if (error instanceof ORPCError2) {
-      return error;
-    }
-    return new ORPCError2("INTERNAL_SERVER_ERROR", {
-      cause: error
-    });
-  }
-  return new ORPCError2("INTERNAL_SERVER_ERROR", {
-    cause: new Error(`${reason.fiberId} Interrupted`)
-  });
-}
 var EffectBuilder = class _EffectBuilder {
   constructor(def) {
     const { runtime, spanConfig, effectErrorMap, ...orpcDef } = def;
@@ -462,6 +516,14 @@ var EffectBuilder = class _EffectBuilder {
       inputSchema: initialInputSchema
     });
   }
+  /**
+   * Creates a middleware.
+   *
+   * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
+   */
+  middleware(middleware) {
+    return decorateMiddleware2(middleware);
+  }
   /**
    * Adds type-safe custom errors.
    * Supports both traditional oRPC error definitions and ORPCTaggedError classes.
@@ -609,35 +671,13 @@ var EffectBuilder = class _EffectBuilder {
     return new EffectDecoratedProcedure({
       ...this["~effect"],
       handler: async (opts) => {
-        const effectOpts = {
-          context: opts.context,
-          input: opts.input,
-          path: opts.path,
-          procedure: opts.procedure,
-          signal: opts.signal,
-          lastEventId: opts.lastEventId,
-          errors: createEffectErrorConstructorMap(
-            this["~effect"].effectErrorMap
-          )
-        };
-        const spanName = spanConfig?.name ?? opts.path.join(".");
-        const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
-        const resolver = Effect.fnUntraced(effectFn);
-        const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
-          captureStackTrace
-        });
-        const parentServices = getCurrentServices();
-        const exit = parentServices ? await Effect.runPromiseExitWith(
-          ServiceMap.merge(await runtime.services(), parentServices)
-        )(tracedEffect, {
-          signal: opts.signal
-        }) : await runtime.runPromiseExit(tracedEffect, {
-          signal: opts.signal
-        });
-        if (Exit.isFailure(exit)) {
-          throw toORPCErrorFromCause(exit.cause);
-        }
-        return exit.value;
+        return createEffectProcedureHandler({
+          runtime,
+          effectErrorMap: this["~effect"].effectErrorMap,
+          effectFn,
+          spanConfig,
+          defaultCaptureStackTrace
+        })(opts);
       }
     });
   }
@@ -710,6 +750,256 @@ function emptyBuilder() {
     dedupeLeadingMiddlewares: true
   });
 }
+
+// src/eoc.ts
+import { isContractProcedure, oc } from "@orpc/contract";
+var effectContractSymbol = /* @__PURE__ */ Symbol.for(
+  "@orpc/effect/contract"
+);
+function isWrappableContractBuilder(value) {
+  return typeof value === "object" && value !== null && "~orpc" in value;
+}
+function mergeEffectErrorMaps(left, right) {
+  if (!left) {
+    return right;
+  }
+  if (!right) {
+    return left;
+  }
+  return {
+    ...left,
+    ...right
+  };
+}
+function setEffectContractErrorMap(value, effectErrorMap) {
+  if (!effectErrorMap) {
+    return;
+  }
+  Object.defineProperty(value, effectContractSymbol, {
+    value: { errorMap: effectErrorMap },
+    enumerable: false,
+    configurable: true
+  });
+}
+function getEffectContractErrorMap(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  return value[effectContractSymbol]?.errorMap;
+}
+function applyEffectContractErrorMapToRouter(router, source, inheritedEffectErrorMap) {
+  const routerRecord = router;
+  const sourceRecord = source;
+  for (const key of Object.keys(routerRecord)) {
+    const routerValue = routerRecord[key];
+    const sourceValue = sourceRecord && typeof sourceRecord === "object" ? sourceRecord[key] : void 0;
+    if (!routerValue) {
+      continue;
+    }
+    if (isContractProcedure(routerValue)) {
+      const sourceEffectErrorMap = getEffectContractErrorMap(sourceValue);
+      setEffectContractErrorMap(
+        routerValue,
+        mergeEffectErrorMaps(inheritedEffectErrorMap, sourceEffectErrorMap)
+      );
+      continue;
+    }
+    if (typeof routerValue === "object") {
+      applyEffectContractErrorMapToRouter(
+        routerValue,
+        sourceValue,
+        inheritedEffectErrorMap
+      );
+    }
+  }
+}
+function wrapEffectContractBuilder(builder, inheritedEffectErrorMap) {
+  const currentEffectErrorMap = inheritedEffectErrorMap ?? getEffectContractErrorMap(builder);
+  if (typeof builder === "object" && builder !== null) {
+    setEffectContractErrorMap(builder, currentEffectErrorMap);
+  }
+  const proxy = new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop === effectContractSymbol) {
+        return currentEffectErrorMap ? { errorMap: currentEffectErrorMap } : void 0;
+      }
+      if (prop === "errors") {
+        return (errors) => {
+          const nextEffectErrorMap = mergeEffectErrorMaps(
+            currentEffectErrorMap,
+            errors
+          );
+          return wrapEffectContractBuilder(
+            Reflect.apply(Reflect.get(target, prop, receiver), target, [
+              effectErrorMapToErrorMap(errors)
+            ]),
+            nextEffectErrorMap
+          );
+        };
+      }
+      if (prop === "router") {
+        return (router) => {
+          const result = Reflect.apply(
+            Reflect.get(target, prop, receiver),
+            target,
+            [router]
+          );
+          applyEffectContractErrorMapToRouter(
+            result,
+            router,
+            currentEffectErrorMap
+          );
+          return result;
+        };
+      }
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value !== "function") {
+        return value;
+      }
+      return (...args) => {
+        const result = Reflect.apply(value, target, args);
+        return isWrappableContractBuilder(result) ? wrapEffectContractBuilder(result, currentEffectErrorMap) : result;
+      };
+    }
+  });
+  setEffectContractErrorMap(proxy, currentEffectErrorMap);
+  return proxy;
+}
+var eoc = wrapEffectContractBuilder(
+  oc,
+  {}
+);
+
+// src/contract.ts
+var CONTRACT_HIDDEN_METHODS = /* @__PURE__ */ new Set([
+  "$config",
+  "$context",
+  "$input",
+  "$meta",
+  "$route",
+  "errors",
+  "input",
+  "lazy",
+  "meta",
+  "middleware",
+  "output",
+  "prefix",
+  "route",
+  "router",
+  "tag"
+]);
+function makeEnhanceOptions(runtime) {
+  return {
+    middlewares: [],
+    errorMap: {},
+    dedupeLeadingMiddlewares: true,
+    runtime
+  };
+}
+function wrapContractNode(contract, target, runtime) {
+  const cache = /* @__PURE__ */ new Map();
+  return new Proxy(target, {
+    get(currentTarget, prop, receiver) {
+      if (cache.has(prop)) {
+        return cache.get(prop);
+      }
+      if (isContractProcedure2(contract)) {
+        if (prop === "effect") {
+          const effect = (effectFn) => {
+            const effectErrorMap = getEffectContractErrorMap(contract) ?? currentTarget["~orpc"].errorMap;
+            return new EffectDecoratedProcedure({
+              ...currentTarget["~orpc"],
+              errorMap: effectErrorMapToErrorMap(effectErrorMap),
+              effectErrorMap,
+              runtime,
+              handler: createEffectProcedureHandler({
+                runtime,
+                effectErrorMap,
+                effectFn,
+                defaultCaptureStackTrace: addSpanStackTrace()
+              })
+            });
+          };
+          cache.set(prop, effect);
+          return effect;
+        }
+        if (prop === "use") {
+          const use = (...args) => wrapContractNode(
+            contract,
+            Reflect.apply(
+              Reflect.get(currentTarget, prop, currentTarget),
+              currentTarget,
+              args
+            ),
+            runtime
+          );
+          cache.set(prop, use);
+          return use;
+        }
+        if (CONTRACT_HIDDEN_METHODS.has(String(prop))) {
+          return void 0;
+        }
+      } else {
+        if (prop === "$context" || prop === "$config" || prop === "use") {
+          const wrappedMethod = (...args) => wrapContractNode(
+            contract,
+            Reflect.apply(
+              Reflect.get(currentTarget, prop, currentTarget),
+              currentTarget,
+              args
+            ),
+            runtime
+          );
+          cache.set(prop, wrappedMethod);
+          return wrappedMethod;
+        }
+        if (prop === "router" || prop === "lazy") {
+          const wrappedMethod = (...args) => enhanceEffectRouter(
+            Reflect.apply(
+              Reflect.get(currentTarget, prop, currentTarget),
+              currentTarget,
+              args
+            ),
+            makeEnhanceOptions(runtime)
+          );
+          cache.set(prop, wrappedMethod);
+          return wrappedMethod;
+        }
+        if (typeof prop === "string" && prop in contract) {
+          const child = wrapContractNode(
+            contract[prop],
+            Reflect.get(currentTarget, prop, receiver),
+            runtime
+          );
+          cache.set(prop, child);
+          return child;
+        }
+      }
+      const value = Reflect.get(currentTarget, prop, receiver);
+      return typeof value === "function" ? value.bind(currentTarget) : value;
+    },
+    has(currentTarget, prop) {
+      if (isContractProcedure2(contract)) {
+        if (prop === "effect") {
+          return true;
+        }
+        if (CONTRACT_HIDDEN_METHODS.has(String(prop))) {
+          return false;
+        }
+      } else if (typeof prop === "string" && prop in contract) {
+        return true;
+      }
+      return Reflect.has(currentTarget, prop);
+    }
+  });
+}
+function implementEffect(contract, runtime) {
+  return wrapContractNode(
+    contract,
+    implement(contract),
+    runtime
+  );
+}
 export {
   EffectBuilder,
   EffectDecoratedProcedure,
@@ -718,6 +1008,8 @@ export {
   addSpanStackTrace,
   createEffectErrorConstructorMap,
   effectErrorMapToErrorMap,
+  eoc,
+  implementEffect,
   isORPCTaggedError,
   isORPCTaggedErrorClass,
   makeEffectORPC,