effect-orpc 0.2.2 → 0.4.0

package/src/runtime-source.ts

@@ -0,0 +1,76 @@
+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 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))
@@ -371,15 +371,6 @@ export type EffectErrorMapItem =
   | ErrorMapItem<AnySchema>
   | AnyORPCTaggedErrorClass;
 
-export type ORPCTaggedErrorClassToErrorMapItem<T> =
-  T extends ORPCTaggedErrorClass<any, any, infer TData>
-    ? {
-        status?: number;
-        message?: string;
-        data?: TData;
-      }
-    : never;
-
 /**
  * Extended error map that supports both traditional oRPC errors and ORPCTaggedError classes.
  *

package/src/tests/contract.test.ts

@@ -62,6 +62,27 @@ describe("implementEffect", () => {
     });
   });
 
+  it("can implement a contract directly from a Layer", async () => {
+    const CounterLive = Layer.succeed(Counter, {
+      increment: (n: number) => Effect.succeed(n + 1),
+    });
+    const oe = implementEffect(contract, CounterLive);
+    const procedure = oe.users.list.effect(function* ({ input }) {
+      const counter = yield* Counter;
+
+      return {
+        next: yield* counter.increment(input.amount),
+        requestId: "layer",
+      };
+    });
+
+    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 () => {
     const oe = implementEffect(contract, runtime);
 

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

@@ -121,7 +121,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).toBe(runtime);
   });
 
   it("preserves tagged class support in errors()", () => {
@@ -155,11 +155,11 @@ 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).toBe(runtime);
     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).toBe(runtime);
   });
 
   it("preserves decorated procedure proxy reflection and extracted methods", () => {
@@ -214,7 +214,7 @@ 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).toBe(runtime);
     expect(callable.route({ path: "/echo" })).toBeInstanceOf(
       EffectDecoratedProcedure,
     );