effect-orpc 0.2.1 → 0.3.0

package/src/tests/contract.test.ts

@@ -62,6 +62,30 @@ 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",
+      };
+    });
+
+    try {
+      await expect(call(procedure, { amount: 2 })).resolves.toEqual({
+        next: 3,
+        requestId: "layer",
+      });
+    } finally {
+      await procedure["~effect"].runtime.dispose();
+    }
+  });
+
   it("preserves contract enforcement at the root router", async () => {
     const oe = implementEffect(contract, runtime);
 

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

@@ -1,14 +1,21 @@
 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 { EffectDecoratedProcedure } from "../effect-procedure";
 import { withFiberContext } from "../node";
-import { effectErrorMapToErrorMap, ORPCTaggedError } from "../tagged-error";
+import { ORPCTaggedError, effectErrorMapToErrorMap } from "../tagged-error";
 import {
   baseErrorMap,
   baseMeta,
@@ -402,6 +409,454 @@ 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);
+    });
+
+    try {
+      await expect(call(procedure, 5)).resolves.toBe(6);
+    } finally {
+      await effectBuilder["~effect"].runtime.dispose();
+    }
+  });
+
+  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);
+    });
+
+    try {
+      await expect(call(procedure, 5)).resolves.toBe(6);
+    } finally {
+      await effectBuilder["~effect"].runtime.dispose();
+    }
+  });
+
+  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),
+      };
+    });
+
+    try {
+      await expect(call(procedure, 5)).resolves.toEqual({
+        fromCustomBuilder: true,
+        value: 6,
+      });
+    } finally {
+      await effectBuilder["~effect"].runtime.dispose();
+    }
+  });
+
+  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 +1085,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/node-side-effect.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from "vitest";
+
+async function makeSplitProcedure(options: {
+  readonly installNodeBridge: boolean;
+}) {
+  vi.resetModules();
+
+  if (options.installNodeBridge) {
+    await import("../node");
+  } else {
+    const { installFiberContextBridge } =
+      await import("../fiber-context-bridge");
+    installFiberContextBridge(undefined);
+  }
+
+  const [
+    { call },
+    { Context, Effect, Layer, ManagedRuntime },
+    { makeEffectORPC },
+  ] = await Promise.all([
+    import("@orpc/server"),
+    import("effect"),
+    import("../effect-builder"),
+  ]);
+
+  class CurrentUser extends Context.Tag("SideEffectImportCurrentUser")<
+    CurrentUser,
+    { readonly id: string }
+  >() {}
+
+  const runtime = ManagedRuntime.make(Layer.empty);
+  const runPromiseExit = vi.spyOn(runtime, "runPromiseExit");
+  const procedure = makeEffectORPC(runtime)
+    .$context<{ readonly user: { readonly id: string } }>()
+    .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+    .use(function* ({ next }) {
+      return yield* next();
+    })
+    .use(({ next }) => next())
+    .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}`;
+    });
+
+  return { call, procedure, runPromiseExit, runtime };
+}
+
+describe("node side-effect bridge", () => {
+  it("propagates FiberRefs across split Effect groups with only the side-effect import", async () => {
+    const { call, procedure, runPromiseExit, runtime } =
+      await makeSplitProcedure({ installNodeBridge: true });
+
+    try {
+      await expect(
+        call(procedure, undefined, { context: { user: { id: "u-side" } } }),
+      ).resolves.toBe("u-side:u-side");
+      expect(runPromiseExit).toHaveBeenCalledTimes(2);
+    } finally {
+      await runtime.dispose();
+    }
+  });
+
+  it("does not propagate FiberRefs across split Effect groups without the bridge", async () => {
+    const { call, procedure, runPromiseExit, runtime } =
+      await makeSplitProcedure({ installNodeBridge: false });
+
+    try {
+      await expect(
+        call(procedure, undefined, { context: { user: { id: "u-side" } } }),
+      ).rejects.toThrow();
+      expect(runPromiseExit).toHaveBeenCalledTimes(2);
+    } finally {
+      await runtime.dispose();
+    }
+  });
+});

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

@@ -42,9 +42,16 @@ const rootBuilder = makeEffectORPC(runtime)
   .$input(inputSchema)
   .errors(baseErrorMap);
 
-const withMiddlewares = rootBuilder.use(({ next }) =>
-  next({ context: { auth: true as boolean } }),
-);
+const authMiddleware: Middleware<
+  InitialContext,
+  { auth: boolean },
+  { input: string },
+  unknown,
+  any,
+  BaseMeta
+> = ({ next }) => next({ context: { auth: true as boolean } });
+
+const withMiddlewares = rootBuilder.use(authMiddleware);
 
 const procedureBuilder = withMiddlewares.meta(baseMeta);
 const withInput = procedureBuilder.input(inputSchema);