effect-orpc 0.3.0 → 0.5.0

package/src/extension/state.ts

@@ -1,5 +1,4 @@
-import type { ManagedRuntime } from "effect";
-
+import type { EffectRuntimeRunner } from "../runtime-source";
 import type { EffectErrorMap } from "../tagged-error";
 import type {
   EffectPipelineStep,
@@ -17,10 +16,9 @@ export interface EffectExtensionState<
    */
   effectErrorMap: EffectErrorMap;
   /**
-   * The Effect ManagedRuntime that provides services for Effect procedures.
-   * @see {@link ManagedRuntime.ManagedRuntime}
+   * Executes Effect values with the services configured for this builder.
    */
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   /**
    * Configuration for Effect span tracing.
    * @see {@link EffectSpanConfig}

package/src/index.ts

@@ -16,6 +16,7 @@ export type {
 export {
   addSpanStackTrace,
   EffectBuilder,
+  eos,
   makeEffectORPC,
 } from "./effect-builder";
 export { EffectDecoratedProcedure } from "./effect-procedure";

package/src/runtime-source.ts

@@ -1,18 +1,76 @@
-import { Layer, ManagedRuntime } from "effect";
+import { Effect, Exit, FiberRefs, Layer, ManagedRuntime } from "effect";
+
+import { getCurrentFiberRefs } from "./fiber-context-bridge";
 
 export type EffectRuntimeSource<TRequirementsProvided, TRuntimeError> =
   | ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>
   | Layer.Layer<TRequirementsProvided, TRuntimeError, never>;
 
-export function toManagedRuntime<TRequirementsProvided, TRuntimeError>(
-  source: EffectRuntimeSource<TRequirementsProvided, TRuntimeError>,
-): ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError> {
-  return ManagedRuntime.isManagedRuntime(source)
-    ? (source as ManagedRuntime.ManagedRuntime<
-        TRequirementsProvided,
-        TRuntimeError
-      >)
-    : ManagedRuntime.make(
-        source as Layer.Layer<TRequirementsProvided, TRuntimeError, never>,
-      );
+export interface EffectRuntimeRunner<TRequirementsProvided, TRuntimeError> {
+  readonly runtime?: ManagedRuntime.ManagedRuntime<
+    TRequirementsProvided,
+    TRuntimeError
+  >;
+  readonly runPromiseExit: <A, E>(
+    effect: Effect.Effect<A, E, TRequirementsProvided>,
+    options?: { readonly signal?: AbortSignal },
+  ) => Promise<Exit.Exit<A, E | TRuntimeError>>;
+}
+
+export function makeEffectRuntimeRunner<
+  TRequirementsProvided = never,
+  TRuntimeError = never,
+>(
+  source?: EffectRuntimeSource<TRequirementsProvided, TRuntimeError>,
+): EffectRuntimeRunner<TRequirementsProvided, TRuntimeError> {
+  if (source === undefined) {
+    return {
+      runPromiseExit: (effect, options) =>
+        Effect.runPromiseExit(withParentFiberRefs(effect as any), {
+          signal: options?.signal,
+        }) as Promise<Exit.Exit<any, any>>,
+    };
+  }
+
+  if (ManagedRuntime.isManagedRuntime(source)) {
+    const runtime = source as ManagedRuntime.ManagedRuntime<
+      TRequirementsProvided,
+      TRuntimeError
+    >;
+    return {
+      runtime,
+      runPromiseExit: (effect, options) =>
+        runtime.runPromiseExit(withParentFiberRefs(effect), {
+          signal: options?.signal,
+        }),
+    };
+  }
+
+  const layer = source as Layer.Layer<
+    TRequirementsProvided,
+    TRuntimeError,
+    never
+  >;
+  return {
+    runPromiseExit: (effect, options) =>
+      Effect.runPromiseExit(
+        withParentFiberRefs(Effect.provide(effect as any, layer)),
+        { signal: options?.signal },
+      ) as Promise<Exit.Exit<any, any>>,
+  };
+}
+
+function withParentFiberRefs<A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+): Effect.Effect<A, E, R> {
+  const parentFiberRefs = getCurrentFiberRefs();
+  return parentFiberRefs
+    ? Effect.fiberIdWith((fiberId) =>
+        Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>
+          Effect.setFiberRefs(
+            FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs),
+          ).pipe(Effect.andThen(effect)),
+        ),
+      )
+    : effect;
 }

package/src/tagged-error.ts

@@ -341,7 +341,7 @@ export function ORPCTaggedError<
  *
  * @example
  * ```ts
- * const handler = effectOs.effect(function* () {
+ * const handler = effectProcedure.effect(function* () {
  *   const result = yield* someOperation.pipe(
  *     Effect.catchTag('UserNotFoundError', (e) =>
  *       Effect.fail(toORPCError(e))

package/src/tests/contract.test.ts

@@ -76,14 +76,11 @@ describe("implementEffect", () => {
       };
     });
 
-    try {
-      await expect(call(procedure, { amount: 2 })).resolves.toEqual({
-        next: 3,
-        requestId: "layer",
-      });
-    } finally {
-      await procedure["~effect"].runtime.dispose();
-    }
+    expect(procedure["~effect"].runner.runtime).toBeUndefined();
+    await expect(call(procedure, { amount: 2 })).resolves.toEqual({
+      next: 3,
+      requestId: "layer",
+    });
   });
 
   it("preserves contract enforcement at the root router", async () => {

package/src/tests/effect-builder.proxy.test.ts

@@ -1,12 +1,10 @@
 import { isLazy, isProcedure, os, unlazy } from "@orpc/server";
-import { Layer, ManagedRuntime } from "effect";
 import { describe, expect, it } from "vitest";
 import z from "zod";
 
-import { EffectBuilder, makeEffectORPC } from "../effect-builder";
+import { EffectBuilder, eos, makeEffectORPC } from "../effect-builder";
 import { EffectDecoratedProcedure } from "../effect-procedure";
 import { ORPCTaggedError } from "../tagged-error";
-const runtime = ManagedRuntime.make(Layer.empty);
 
 function makeCustomBuilder(meta: Record<string, unknown> = {}): {
   "~orpc": (typeof os)["~orpc"];
@@ -32,7 +30,7 @@ function makeCustomBuilder(meta: Record<string, unknown> = {}): {
 
 describe("effectBuilder proxy compatibility", () => {
   it("preserves instanceof and virtual reflection surface", () => {
-    const builder = makeEffectORPC(runtime);
+    const builder = eos;
 
     expect(builder).toBeInstanceOf(EffectBuilder);
     expect("~orpc" in builder).toBe(true);
@@ -82,7 +80,7 @@ describe("effectBuilder proxy compatibility", () => {
   });
 
   it("keeps extracted forwarded and intercepted methods callable", () => {
-    const builder = makeEffectORPC(runtime).$meta({ mode: "dev" });
+    const builder = eos.$meta({ mode: "dev" });
 
     const meta = builder.meta;
     const prefixed = builder.prefix;
@@ -102,8 +100,8 @@ describe("effectBuilder proxy compatibility", () => {
   });
 
   it("preserves wrapped chaining across forwarded and intercepted methods", () => {
-    const routedBuilder = makeEffectORPC(runtime).prefix("/api").tag("users");
-    const builder = makeEffectORPC(runtime)
+    const routedBuilder = eos.prefix("/api").tag("users");
+    const builder = eos
       .$meta({ scope: "users" })
       .errors({ BAD_REQUEST: { message: "bad request" } })
       .traced("users.list")
@@ -121,7 +119,7 @@ describe("effectBuilder proxy compatibility", () => {
       ({ input }: { input: { id: string } }) => input,
     );
     expect(procedure).toBeInstanceOf(EffectDecoratedProcedure);
-    expect(procedure["~effect"].runtime).toBe(runtime);
+    expect(procedure["~effect"].runner.runtime).toBeUndefined();
   });
 
   it("preserves tagged class support in errors()", () => {
@@ -130,7 +128,7 @@ describe("effectBuilder proxy compatibility", () => {
       schema: z.object({ userId: z.string() }),
     }) {}
 
-    const builder = makeEffectORPC(runtime).errors({
+    const builder = eos.errors({
       UserNotFoundError,
     });
 
@@ -141,7 +139,7 @@ describe("effectBuilder proxy compatibility", () => {
   });
 
   it("keeps handler, effect, router, and lazy return behavior unchanged", async () => {
-    const builder = makeEffectORPC(runtime);
+    const builder = eos;
     const procedure = builder.effect(function* () {
       return { output: "pong" };
     });
@@ -155,15 +153,15 @@ describe("effectBuilder proxy compatibility", () => {
 
     expect(handled).toBeInstanceOf(EffectDecoratedProcedure);
     expect(effected).toBeInstanceOf(EffectDecoratedProcedure);
-    expect(routed.ping["~effect"].runtime).toBe(runtime);
+    expect(routed.ping["~effect"].runner.runtime).toBeUndefined();
     expect(isLazy(lazied)).toBe(true);
 
     const { default: resolved } = await unlazy(lazied as any);
-    expect(resolved.ping["~effect"].runtime).toBe(runtime);
+    expect(resolved.ping["~effect"].runner.runtime).toBeUndefined();
   });
 
   it("preserves decorated procedure proxy reflection and extracted methods", () => {
-    const procedure = makeEffectORPC(runtime)
+    const procedure = eos
       .route({ path: "/users" })
       .handler(({ input }) => input);
 
@@ -206,7 +204,7 @@ describe("effectBuilder proxy compatibility", () => {
   });
 
   it("keeps callable procedure clients executable while exposing the procedure surface", async () => {
-    const procedure = makeEffectORPC(runtime).handler(({ input }) => ({
+    const procedure = eos.handler(({ input }) => ({
       echoed: input,
     }));
 
@@ -214,14 +212,14 @@ describe("effectBuilder proxy compatibility", () => {
 
     await expect(callable("hello")).resolves.toEqual({ echoed: "hello" });
     expect(callable).toSatisfy(isProcedure);
-    expect(callable["~effect"].runtime).toBe(runtime);
+    expect(callable["~effect"].runner.runtime).toBeUndefined();
     expect(callable.route({ path: "/echo" })).toBeInstanceOf(
       EffectDecoratedProcedure,
     );
   });
 
   it("applies builder route and middleware enhancements to routed procedures", () => {
-    const builder = makeEffectORPC(runtime);
+    const builder = eos;
     const middleware = builder.middleware(({ next }) => next({}));
     const procedure = builder.route({ path: "/ping" }).handler(() => "pong");
 
@@ -238,7 +236,7 @@ describe("effectBuilder proxy compatibility", () => {
   });
 
   it("rewraps unknown builder-like methods and passes through non-builder results", () => {
-    const builder = makeEffectORPC(runtime, makeCustomBuilder() as any) as any;
+    const builder = makeEffectORPC(makeCustomBuilder() as any) as any;
 
     const customBuilderLike = builder.customBuilderLike;
     const customValue = builder.customValue;