effect-orpc 0.2.2 → 0.4.0

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

@@ -1,14 +1,22 @@
 import type { InferSchemaOutput } from "@orpc/contract";
 import { isContractProcedure } from "@orpc/contract";
-import { os } from "@orpc/server";
-import { Effect, FiberRef, Layer, ManagedRuntime } from "effect";
+import { call, os } from "@orpc/server";
+import {
+  Context,
+  Effect,
+  FiberRef,
+  Layer,
+  ManagedRuntime,
+  Option,
+} from "effect";
 import { beforeEach, describe, expect, expectTypeOf, it, vi } 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 { withFiberContext } from "../node";
-import { effectErrorMapToErrorMap, ORPCTaggedError } from "../tagged-error";
+import { makeEffectRuntimeRunner } from "../runtime-source";
+import { ORPCTaggedError, effectErrorMapToErrorMap } from "../tagged-error";
 import {
   baseErrorMap,
   baseMeta,
@@ -20,6 +28,7 @@ import {
 
 const mid = vi.fn();
 const runtime = ManagedRuntime.make(Layer.empty);
+const runner = makeEffectRuntimeRunner(runtime);
 
 const def = {
   config: {
@@ -36,6 +45,7 @@ const def = {
   outputValidationIndex: 88,
   route: baseRoute,
   dedupeLeadingMiddlewares: true,
+  runner,
   runtime,
 };
 
@@ -135,7 +145,7 @@ describe("effectBuilder", () => {
     const applied = builder.effect(effectFn);
 
     expect(applied).instanceOf(EffectDecoratedProcedure);
-    expect(applied["~effect"].runtime).toBe(runtime);
+    expect(applied["~effect"].runner.runtime).toBe(runtime);
     expect(applied["~effect"].handler).toBeInstanceOf(Function);
   });
 
@@ -264,7 +274,7 @@ describe("makeEffectORPC factory", () => {
     const effectBuilder = makeEffectORPC(runtime);
 
     expect(effectBuilder).instanceOf(EffectBuilder);
-    expect(effectBuilder["~effect"].runtime).toBe(runtime);
+    expect(effectBuilder["~effect"].runner.runtime).toBe(runtime);
     // Should inherit os's default definition
     expect(effectBuilder["~effect"].middlewares).toEqual(
       os["~orpc"].middlewares,
@@ -278,7 +288,7 @@ describe("makeEffectORPC factory", () => {
     const effectBuilder = makeEffectORPC(runtime, os);
 
     expect(effectBuilder).instanceOf(EffectBuilder);
-    expect(effectBuilder["~effect"].runtime).toBe(runtime);
+    expect(effectBuilder["~effect"].runner.runtime).toBe(runtime);
     expect(effectBuilder["~effect"].middlewares).toEqual(
       os["~orpc"].middlewares,
     );
@@ -287,6 +297,46 @@ describe("makeEffectORPC factory", () => {
     );
   });
 
+  it("exports an eos builder that works with provide", async () => {
+    class Counter extends Effect.Tag("EosCounter")<
+      Counter,
+      { increment: (n: number) => Effect.Effect<number> }
+    >() {}
+
+    const procedure = eos
+      .provide(
+        Layer.succeed(Counter, {
+          increment: (n: number) => Effect.succeed(n + 1),
+        }),
+      )
+      .input(z.number())
+      .effect(function* ({ input }) {
+        const counter = yield* Counter;
+        return yield* counter.increment(input as number);
+      });
+
+    expect(eos["~effect"].runner.runtime).toBeUndefined();
+    await expect(call(procedure, 5)).resolves.toBe(6);
+  });
+
+  it("does not own a ManagedRuntime when no source is provided", () => {
+    const effectBuilder = makeEffectORPC();
+
+    expect(effectBuilder["~effect"].runner.runtime).toBeUndefined();
+  });
+
+  it("does not own a ManagedRuntime when only a builder is provided", () => {
+    const effectBuilder = makeEffectORPC(os);
+
+    expect(effectBuilder["~effect"].runner.runtime).toBeUndefined();
+  });
+
+  it("does not own a ManagedRuntime when a Layer is provided", () => {
+    const effectBuilder = makeEffectORPC(Layer.empty);
+
+    expect(effectBuilder["~effect"].runner.runtime).toBeUndefined();
+  });
+
   it("creates working procedure with default os", async () => {
     const effectBuilder = makeEffectORPC(runtime);
 
@@ -402,6 +452,445 @@ describe("effect with services", () => {
     // Cleanup
     await serviceRuntime.dispose();
   });
+
+  it("can create a builder directly from a Layer", async () => {
+    class Counter extends Effect.Tag("LayerCounter")<
+      Counter,
+      { increment: (n: number) => Effect.Effect<number> }
+    >() {}
+
+    const CounterLive = Layer.succeed(Counter, {
+      increment: (n: number) => Effect.succeed(n + 1),
+    });
+    const effectBuilder = makeEffectORPC(CounterLive);
+    const procedure = effectBuilder.input(z.number()).effect(function* ({
+      input,
+    }) {
+      const counter = yield* Counter;
+      return yield* counter.increment(input as number);
+    });
+
+    expect(effectBuilder["~effect"].runner.runtime).toBeUndefined();
+    await expect(call(procedure, 5)).resolves.toBe(6);
+  });
+
+  it("can start without a runtime and provide a Layer", async () => {
+    class Counter extends Effect.Tag("ProvidedLayerCounter")<
+      Counter,
+      { increment: (n: number) => Effect.Effect<number> }
+    >() {}
+
+    const CounterLive = Layer.succeed(Counter, {
+      increment: (n: number) => Effect.succeed(n + 1),
+    });
+    const effectBuilder = makeEffectORPC().provide(CounterLive);
+    const procedure = effectBuilder.input(z.number()).effect(function* ({
+      input,
+    }) {
+      const counter = yield* Counter;
+      return yield* counter.increment(input as number);
+    });
+
+    expect(effectBuilder["~effect"].runner.runtime).toBeUndefined();
+    await expect(call(procedure, 5)).resolves.toBe(6);
+  });
+
+  it("can wrap a custom builder without a runtime and provide a Layer", async () => {
+    class Counter extends Effect.Tag("ProvidedLayerCustomBuilderCounter")<
+      Counter,
+      { increment: (n: number) => Effect.Effect<number> }
+    >() {}
+
+    const CounterLive = Layer.succeed(Counter, {
+      increment: (n: number) => Effect.succeed(n + 1),
+    });
+    const customBuilder = os.use(({ next }) =>
+      next({ context: { fromCustomBuilder: true } }),
+    );
+    const effectBuilder = makeEffectORPC(customBuilder).provide(CounterLive);
+    const procedure = effectBuilder.input(z.number()).effect(function* ({
+      context,
+      input,
+    }) {
+      const counter = yield* Counter;
+      return {
+        fromCustomBuilder: context.fromCustomBuilder,
+        value: yield* counter.increment(input as number),
+      };
+    });
+
+    expect(effectBuilder["~effect"].runner.runtime).toBeUndefined();
+    await expect(call(procedure, 5)).resolves.toEqual({
+      fromCustomBuilder: true,
+      value: 6,
+    });
+  });
+
+  it(".provide makes a request-scoped service available to handlers", async () => {
+    class CurrentUser extends Context.Tag("CurrentUser")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const effectBuilder = makeEffectORPC(runtime).$context<{
+      user: { id: string };
+    }>();
+    const procedure = effectBuilder
+      .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+      .effect(function* () {
+        return yield* CurrentUser;
+      });
+
+    await expect(
+      call(procedure, undefined, { context: { user: { id: "u-1" } } }),
+    ).resolves.toEqual({ id: "u-1" });
+  });
+
+  it(".provide service overrides the same service from the runtime", async () => {
+    class CurrentUser extends Context.Tag("CurrentUserOverride")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const serviceRuntime = ManagedRuntime.make(
+      Layer.succeed(CurrentUser, { id: "runtime" }),
+    );
+    const effectBuilder = makeEffectORPC(serviceRuntime).$context<{
+      user: { id: string };
+    }>();
+    const procedure = effectBuilder
+      .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+      .effect(function* () {
+        return yield* CurrentUser;
+      });
+
+    try {
+      await expect(
+        call(procedure, undefined, { context: { user: { id: "request" } } }),
+      ).resolves.toEqual({ id: "request" });
+    } finally {
+      await serviceRuntime.dispose();
+    }
+  });
+
+  it("Effect .use yield* next() without return runs handler once", async () => {
+    let runs = 0;
+    const procedure = makeEffectORPC(runtime)
+      .use(function* ({ next }) {
+        yield* Effect.void;
+        yield* next();
+      })
+      .effect(function* () {
+        runs += 1;
+        return "ok";
+      });
+
+    await expect(call(procedure, undefined)).resolves.toBe("ok");
+    expect(runs).toBe(1);
+  });
+
+  it("Effect .use guard-only middleware without next runs handler once", async () => {
+    let runs = 0;
+    const procedure = makeEffectORPC(runtime)
+      .use(function* () {
+        yield* Effect.void;
+      })
+      .effect(function* () {
+        runs += 1;
+        return "ok";
+      });
+
+    await expect(call(procedure, undefined)).resolves.toBe("ok");
+    expect(runs).toBe(1);
+  });
+
+  it("Effect .use yield* next() without return stays in one runtime boundary", async () => {
+    const runPromiseExit = vi.spyOn(runtime, "runPromiseExit");
+    const procedure = makeEffectORPC(runtime)
+      .use(function* ({ next }) {
+        yield* next();
+      })
+      .effect(function* () {
+        return "ok";
+      });
+
+    await expect(call(procedure, undefined)).resolves.toBe("ok");
+    expect(runPromiseExit).toHaveBeenCalledTimes(1);
+  });
+
+  it("Effect .use can read services from upstream .provide", async () => {
+    class CurrentUser extends Context.Tag("MiddlewareCurrentUser")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    let seenUser: { id: string } | undefined;
+    const effectBuilder = makeEffectORPC(runtime).$context<{
+      user: { id: string };
+    }>();
+    const procedure = effectBuilder
+      .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+      .use(function* () {
+        seenUser = yield* CurrentUser;
+      })
+      .effect(function* () {
+        return "ok";
+      });
+
+    await expect(
+      call(procedure, undefined, { context: { user: { id: "u-2" } } }),
+    ).resolves.toBe("ok");
+    expect(seenUser).toEqual({ id: "u-2" });
+  });
+
+  it("Effect .middleware can create reusable generator middleware", async () => {
+    const eos = makeEffectORPC(runtime);
+
+    const reusable = eos.middleware(function* ({ next }, input: string) {
+      expectTypeOf(input).toEqualTypeOf<string>();
+      return yield* next({ context: { seenInput: input } });
+    });
+
+    const procedure = eos
+      .input(z.string())
+      .use(reusable)
+      .effect(function* ({ context }) {
+        expectTypeOf(context.seenInput).toEqualTypeOf<string>();
+        return context.seenInput;
+      });
+
+    await expect(call(procedure, "ok")).resolves.toBe("ok");
+  });
+
+  it("Effect .middleware can use builder-provided services", async () => {
+    class MiddlewareService extends Context.Tag("MiddlewareService")<
+      MiddlewareService,
+      { value: string }
+    >() {}
+
+    const eos = makeEffectORPC(runtime).provide(MiddlewareService, () =>
+      Effect.succeed({ value: "provided" }),
+    );
+
+    const reusable = eos.middleware(function* ({ next }) {
+      const service = yield* MiddlewareService;
+      return yield* next({ context: { serviceValue: service.value } });
+    });
+
+    const procedure = eos.use(reusable).effect(function* ({ context }) {
+      return context.serviceValue;
+    });
+
+    await expect(call(procedure, undefined)).resolves.toBe("provided");
+  });
+
+  it("Effect .use can enrich context through next", async () => {
+    class CurrentUser extends Context.Tag("NextCurrentUser")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const effectBuilder = makeEffectORPC(runtime).$context<{
+      user: { id: string };
+    }>();
+    const procedure = effectBuilder
+      .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+      .use(function* ({ next }, _input) {
+        const user = yield* CurrentUser;
+        return yield* next({ context: { userId: user.id } });
+      })
+      .effect(function* ({ context }) {
+        return context.userId;
+      });
+
+    await expect(
+      call(procedure, undefined, { context: { user: { id: "u-3" } } }),
+    ).resolves.toBe("u-3");
+  });
+
+  it("Effect .use can transform downstream output", async () => {
+    const procedure = makeEffectORPC(runtime)
+      .use(function* ({ next }, _input, output) {
+        const result = yield* next();
+        return yield* output(`${result.output}-wrapped`);
+      })
+      .effect(function* () {
+        return "ok";
+      });
+
+    await expect(call(procedure, undefined)).resolves.toBe("ok-wrapped");
+  });
+
+  it("Effect .use can transform typed downstream output after .output", async () => {
+    const procedure = makeEffectORPC(runtime)
+      .output(z.string())
+      .use(function* ({ next }, _input, output) {
+        const result = yield* next();
+        expectTypeOf(result.output).toEqualTypeOf<string>();
+        return yield* output(`${result.output}-wrapped`);
+      })
+      .effect(function* () {
+        return "ok";
+      });
+
+    await expect(call(procedure, undefined)).resolves.toBe("ok-wrapped");
+  });
+
+  it("Effect .use can read typed input after .input", async () => {
+    const procedure = makeEffectORPC(runtime)
+      .input(z.object({ value: z.number() }))
+      .use(function* ({ next }, input) {
+        expectTypeOf(input).toMatchTypeOf<{ value: number }>();
+        return yield* next({ context: { doubled: input.value * 2 } });
+      })
+      .effect(function* ({ context }) {
+        return context.doubled;
+      });
+
+    await expect(call(procedure, { value: 21 })).resolves.toBe(42);
+  });
+
+  it("Effect .use can read typed input and output after .input().output()", async () => {
+    const procedure = makeEffectORPC(runtime)
+      .input(z.object({ value: z.number() }))
+      .output(z.string())
+      .use(function* ({ next }, input, output) {
+        expectTypeOf(input).toMatchTypeOf<{ value: number }>();
+        const result = yield* next();
+        expectTypeOf(result.output).toEqualTypeOf<string>();
+        return yield* output(`${input.value}:${result.output}`);
+      })
+      .effect(function* () {
+        return "ok";
+      });
+
+    await expect(call(procedure, { value: 21 })).resolves.toBe("21:ok");
+  });
+
+  it("Effect .use can transform typed downstream output after .effect", async () => {
+    const procedure = makeEffectORPC(runtime)
+      .effect(function* () {
+        return "ok";
+      })
+      .use(function* ({ next }, _input, output) {
+        const result = yield* next();
+        expectTypeOf(result.output).toEqualTypeOf<string>();
+        return yield* output(`${result.output}-wrapped`);
+      });
+
+    await expect(call(procedure, undefined)).resolves.toBe("ok-wrapped");
+  });
+
+  it("runs contiguous Effect providers, middleware, and handler in one runtime boundary", async () => {
+    class CurrentUser extends Context.Tag("SingleBoundaryCurrentUser")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const runPromiseExit = vi.spyOn(runtime, "runPromiseExit");
+    const procedure = makeEffectORPC(runtime)
+      .$context<{ user: { id: string } }>()
+      .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+      .use(function* ({ next }) {
+        const user = yield* CurrentUser;
+        return yield* next({ context: { userId: user.id } });
+      })
+      .effect(function* ({ context }) {
+        const user = yield* CurrentUser;
+        return `${context.userId}:${user.id}`;
+      });
+
+    await expect(
+      call(procedure, undefined, { context: { user: { id: "u-4" } } }),
+    ).resolves.toBe("u-4:u-4");
+    expect(runPromiseExit).toHaveBeenCalledTimes(1);
+  });
+
+  it("runs procedure-level Effect providers and middleware with the handler in one runtime boundary", async () => {
+    class CurrentUser extends Context.Tag("ProcedureBoundaryCurrentUser")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const runPromiseExit = vi.spyOn(runtime, "runPromiseExit");
+    const procedure = makeEffectORPC(runtime)
+      .$context<{ user: { id: string } }>()
+      .effect(function* () {
+        return "ok";
+      })
+      .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+      .use(function* ({ next }) {
+        const user = yield* CurrentUser;
+        const result = yield* next({ context: { userId: user.id } });
+        return {
+          ...result,
+          output: `${result.output}:${user.id}`,
+        };
+      });
+
+    await expect(
+      call(procedure, undefined, { context: { user: { id: "u-5" } } }),
+    ).resolves.toBe("ok:u-5");
+    expect(runPromiseExit).toHaveBeenCalledTimes(1);
+  });
+
+  it(".provideOptional makes present request-scoped services available", async () => {
+    class CurrentUser extends Context.Tag("OptionalCurrentUserPresent")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const procedure = makeEffectORPC(runtime)
+      .$context<{ user?: { id: string } }>()
+      .provideOptional(CurrentUser, ({ context }) =>
+        Effect.succeed(Option.fromNullable(context.user)),
+      )
+      .effect(function* () {
+        return yield* Effect.serviceOption(CurrentUser);
+      });
+
+    await expect(
+      call(procedure, undefined, { context: { user: { id: "u-6" } } }),
+    ).resolves.toEqual(Option.some({ id: "u-6" }));
+  });
+
+  it(".provideOptional leaves absent request-scoped services unavailable", async () => {
+    class CurrentUser extends Context.Tag("OptionalCurrentUserAbsent")<
+      CurrentUser,
+      { id: string }
+    >() {}
+
+    const procedure = makeEffectORPC(runtime)
+      .$context<{ user?: { id: string } }>()
+      .provideOptional(CurrentUser, ({ context }) =>
+        Effect.succeed(Option.fromNullable(context.user)),
+      )
+      .effect(function* () {
+        return yield* Effect.serviceOption(CurrentUser);
+      });
+
+    await expect(call(procedure, undefined, { context: {} })).resolves.toEqual(
+      Option.none(),
+    );
+  });
+
+  it(".provideOptional does not satisfy required service access", () => {
+    class OptionalService extends Context.Tag("OptionalServiceRequirement")<
+      OptionalService,
+      { readonly value: string }
+    >() {}
+
+    makeEffectORPC(runtime)
+      .provideOptional(OptionalService, () =>
+        Effect.succeed(Option.some({ value: "provided" })),
+      )
+      .effect(
+        // @ts-expect-error provideOptional does not guarantee the service exists
+        function* () {
+          return yield* OptionalService;
+        },
+      );
+  });
 });
 
 describe(".traced", () => {
@@ -630,4 +1119,52 @@ describe("default tracing (without .traced())", () => {
     >;
     expectTypeOf<ProcedureOutput>().toEqualTypeOf<{ name: string }>();
   });
+
+  it("requires handler services to come from the runtime or .provide", () => {
+    class MissingService extends Context.Tag("MissingService")<
+      MissingService,
+      { readonly value: string }
+    >() {}
+
+    makeEffectORPC(runtime).effect(
+      // @ts-expect-error MissingService is not available from the runtime or .provide
+      function* () {
+        return yield* MissingService;
+      },
+    );
+
+    makeEffectORPC(runtime)
+      .provide(MissingService, () => Effect.succeed({ value: "provided" }))
+      .effect(function* () {
+        return yield* MissingService;
+      });
+  });
+
+  it("requires Effect middleware services to come from the runtime or .provide", () => {
+    class MissingMiddlewareService extends Context.Tag(
+      "MissingMiddlewareService",
+    )<MissingMiddlewareService, { readonly value: string }>() {}
+
+    makeEffectORPC(runtime)
+      .use(
+        // @ts-expect-error MissingMiddlewareService is not available from the runtime or .provide
+        function* () {
+          yield* MissingMiddlewareService;
+        },
+      )
+      .effect(function* () {
+        return "ok";
+      });
+
+    makeEffectORPC(runtime)
+      .provide(MissingMiddlewareService, () =>
+        Effect.succeed({ value: "provided" }),
+      )
+      .use(function* () {
+        yield* MissingMiddlewareService;
+      })
+      .effect(function* () {
+        return "ok";
+      });
+  });
 });

package/src/tests/effect-error-map.test.ts

@@ -193,10 +193,10 @@ describe("effectErrorMapToErrorMap", () => {
 
 describe("effectBuilder with EffectErrorMap", () => {
   const runtime = ManagedRuntime.make(Layer.empty);
-  const effectOs = makeEffectORPC(runtime);
+  const effectProcedure = makeEffectORPC(runtime);
 
   it("should support errors() with traditional format", () => {
-    const builder = effectOs.errors({
+    const builder = effectProcedure.errors({
       BAD_REQUEST: { status: 400, message: "Bad request" },
     });
 
@@ -206,7 +206,7 @@ describe("effectBuilder with EffectErrorMap", () => {
   });
 
   it("should support errors() with tagged error classes", () => {
-    const builder = effectOs.errors({
+    const builder = effectProcedure.errors({
       USER_NOT_FOUND_ERROR: UserNotFoundError,
       FORBIDDEN: PermissionDenied,
     });
@@ -218,7 +218,7 @@ describe("effectBuilder with EffectErrorMap", () => {
   });
 
   it("should support mixed error format", () => {
-    const builder = effectOs.errors({
+    const builder = effectProcedure.errors({
       BAD_REQUEST: { status: 400 },
       USER_NOT_FOUND_ERROR: UserNotFoundError,
     });
@@ -232,7 +232,7 @@ describe("effectBuilder with EffectErrorMap", () => {
   });
 
   it("should merge errors correctly", () => {
-    const builder = effectOs
+    const builder = effectProcedure
       .errors({ BAD_REQUEST: { status: 400 } })
       .errors({ USER_NOT_FOUND_ERROR: UserNotFoundError })
       .errors({ FORBIDDEN: PermissionDenied });
@@ -245,7 +245,7 @@ describe("effectBuilder with EffectErrorMap", () => {
   });
 
   it("should create procedure with effect handler", async () => {
-    const procedure = effectOs
+    const procedure = effectProcedure
       .errors({
         USER_NOT_FOUND_ERROR: UserNotFoundError,
         BAD_REQUEST: { status: 400 },
@@ -267,7 +267,7 @@ describe("effectBuilder with EffectErrorMap", () => {
   });
 
   it("should allow throwing tagged errors in effect handler", async () => {
-    const procedure = effectOs
+    const procedure = effectProcedure
       .errors({
         USER_NOT_FOUND_ERROR: UserNotFoundError,
       })
@@ -310,10 +310,10 @@ describe("effectBuilder with EffectErrorMap", () => {
 
 describe("effectDecoratedProcedure.errors()", () => {
   const runtime = ManagedRuntime.make(Layer.empty);
-  const effectOs = makeEffectORPC(runtime);
+  const effectProcedure = makeEffectORPC(runtime);
 
   it("should support adding errors to procedure", () => {
-    const procedure = effectOs
+    const procedure = effectProcedure
       .input(z.object({ id: z.string() }))
       .effect(function* ({ input }) {
         return { id: input.id };
@@ -326,7 +326,7 @@ describe("effectDecoratedProcedure.errors()", () => {
   });
 
   it("should merge errors on procedure", () => {
-    const procedure = effectOs
+    const procedure = effectProcedure
       .errors({ BAD_REQUEST: { status: 400 } })
       .input(z.object({ id: z.string() }))
       .effect(function* ({ input }) {