effect-orpc 0.1.4 → 0.2.1

package/src/tests/contract.test.ts

@@ -0,0 +1,346 @@
+import { oc, type InferSchemaOutput } from "@orpc/contract";
+import { call, ORPCError, type Router } from "@orpc/server";
+import { Effect, FiberRef, Layer, ManagedRuntime } from "effect";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import z from "zod";
+
+import { eoc, implementEffect, ORPCTaggedError } from "../index";
+import { withFiberContext } from "../node";
+
+class Counter extends Effect.Tag("Counter")<
+  Counter,
+  {
+    readonly increment: (n: number) => Effect.Effect<number>;
+  }
+>() {}
+
+const requestIdRef = FiberRef.unsafeMake("missing");
+
+const runtime = ManagedRuntime.make(
+  Layer.succeed(Counter, {
+    increment: (n: number) => Effect.succeed(n + 1),
+  }),
+);
+
+const contract = {
+  users: {
+    list: oc
+      .input(z.object({ amount: z.number() }))
+      .output(z.object({ next: z.number(), requestId: z.string() })),
+  },
+};
+
+describe("implementEffect", () => {
+  it("mirrors the contract tree and adds effect support on leaves", async () => {
+    const oe = implementEffect(contract, runtime);
+
+    expect(oe.users).toBeDefined();
+    expect(oe.users.list).toBeDefined();
+    expect(oe.users.list.handler).toBeTypeOf("function");
+    expect(oe.users.list.effect).toBeTypeOf("function");
+
+    const procedure = oe.users.list.effect(function* ({ input }) {
+      const counter = yield* Counter;
+      const requestId = yield* FiberRef.get(requestIdRef);
+
+      return {
+        next: yield* counter.increment(input.amount),
+        requestId,
+      };
+    });
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        yield* FiberRef.set(requestIdRef, "req-123");
+        return yield* withFiberContext(() => call(procedure, { amount: 2 }));
+      }),
+    );
+
+    expect(result).toEqual({
+      next: 3,
+      requestId: "req-123",
+    });
+  });
+
+  it("preserves contract enforcement at the root router", async () => {
+    const oe = implementEffect(contract, runtime);
+
+    const router = oe.router({
+      users: {
+        list: oe.users.list.effect(function* ({ input }) {
+          const counter = yield* Counter;
+
+          return {
+            next: yield* counter.increment(input.amount),
+            requestId: yield* FiberRef.get(requestIdRef),
+          };
+        }),
+      },
+    });
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        yield* FiberRef.set(requestIdRef, "req-456");
+        return yield* withFiberContext(() =>
+          call(router.users.list, { amount: 4 }),
+        );
+      }),
+    );
+
+    expect(result).toEqual({
+      next: 5,
+      requestId: "req-456",
+    });
+
+    expectTypeOf(router.users.list["~effect"]).toBeObject();
+    expectTypeOf(router).toExtend<
+      Router<typeof contract, Record<string, never>>
+    >();
+  });
+
+  it("maps tagged errors and raw ORPCError values the same way as EffectBuilder", async () => {
+    class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
+      code: "NOT_FOUND",
+      schema: z.object({ userId: z.string() }),
+    }) {}
+
+    const taggedContract = {
+      users: {
+        find: eoc
+          .errors({
+            NOT_FOUND: UserNotFoundError,
+          })
+          .input(z.object({ userId: z.string() }))
+          .output(z.object({ userId: z.string() })),
+      },
+    };
+
+    const oe = implementEffect(taggedContract, runtime);
+
+    const taggedProcedure = oe.users.find.effect(function* ({ input }) {
+      return yield* Effect.fail(
+        new UserNotFoundError({ data: { userId: input.userId } }),
+      );
+    });
+
+    await expect(
+      call(taggedProcedure, { userId: "u-1" }),
+    ).rejects.toMatchObject({
+      code: "NOT_FOUND",
+      data: { userId: "u-1" },
+    });
+
+    const rawProcedure = oe.users.find.effect(function* () {
+      return yield* Effect.fail(
+        new ORPCError("FORBIDDEN", {
+          data: { userId: "nope" },
+        }),
+      );
+    });
+
+    await expect(call(rawProcedure, { userId: "u-2" })).rejects.toMatchObject({
+      code: "FORBIDDEN",
+      data: { userId: "nope" },
+    });
+  });
+
+  it("preserves tagged error constructors from eoc inside effect handlers", async () => {
+    class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
+      schema: z.object({ userId: z.string() }),
+    }) {}
+
+    const taggedContract = {
+      users: {
+        find: eoc
+          .errors({
+            NOT_FOUND: UserNotFoundError,
+            FORBIDDEN: {},
+          })
+          .input(z.object({ userId: z.string() }))
+          .output(z.object({ userId: z.string() })),
+      },
+    };
+
+    const oe = implementEffect(taggedContract, runtime);
+    let taggedError:
+      | ORPCError<"USER_NOT_FOUND_ERROR", { userId: string }>
+      | undefined;
+    let forbiddenError: ORPCError<"FORBIDDEN", unknown> | undefined;
+
+    const procedure = oe.users.find.effect(function* ({ input, errors }) {
+      taggedError = errors.NOT_FOUND({
+        data: { userId: input.userId },
+      });
+      forbiddenError = errors.FORBIDDEN();
+
+      return yield* Effect.fail(taggedError);
+    });
+
+    const result = call(procedure, { userId: "u-3" });
+    await expect(result).rejects.toMatchObject({
+      code: "USER_NOT_FOUND_ERROR",
+      data: { userId: "u-3" },
+    });
+    await expect(result).rejects.toBeInstanceOf(ORPCError);
+
+    expect(taggedError).toBeInstanceOf(UserNotFoundError);
+    expect(forbiddenError).toBeInstanceOf(ORPCError);
+  });
+
+  it("preserves tagged error constructors with custom code from eoc inside effect handlers", async () => {
+    class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
+      schema: z.object({ userId: z.string() }),
+      code: "NOT_FOUND",
+    }) {}
+
+    const taggedContract = {
+      users: {
+        find: eoc
+          .errors({
+            UserNotFoundError,
+            FORBIDDEN: {},
+          })
+          .input(z.object({ userId: z.string() }))
+          .output(z.object({ userId: z.string() })),
+      },
+    };
+
+    const oe = implementEffect(taggedContract, runtime);
+    let taggedError: ORPCError<"NOT_FOUND", { userId: string }> | undefined;
+    let forbiddenError: ORPCError<"FORBIDDEN", unknown> | undefined;
+
+    const procedure = oe.users.find.effect(function* ({ input, errors }) {
+      taggedError = errors.UserNotFoundError({
+        data: { userId: input.userId },
+      });
+      forbiddenError = errors.FORBIDDEN();
+
+      return yield* Effect.fail(taggedError);
+    });
+
+    const result = call(procedure, { userId: "u-3" });
+    await expect(result).rejects.toMatchObject({
+      code: "NOT_FOUND",
+      data: { userId: "u-3" },
+    });
+    await expect(result).rejects.toBeInstanceOf(ORPCError);
+
+    expect(taggedError).toBeInstanceOf(UserNotFoundError);
+    expect(forbiddenError).toBeInstanceOf(ORPCError);
+  });
+
+  it("preserves tagged error constructors through eoc.router contracts", async () => {
+    class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
+      schema: z.object({ userId: z.string() }),
+    }) {}
+
+    const routedContract = eoc
+      .errors({
+        NOT_FOUND: UserNotFoundError,
+      })
+      .router({
+        users: {
+          find: oc
+            .input(z.object({ userId: z.string() }))
+            .output(z.object({ userId: z.string() })),
+        },
+      });
+
+    const oe = implementEffect(routedContract, runtime);
+    let taggedError:
+      | ORPCError<"USER_NOT_FOUND_ERROR", { userId: string }>
+      | undefined;
+
+    const procedure = oe.users.find.effect(function* ({ input, errors }) {
+      taggedError = errors.NOT_FOUND({ data: { userId: input.userId } });
+      return yield* Effect.fail(taggedError);
+    });
+
+    const result = call(procedure, { userId: "u-4" });
+    await expect(result).rejects.toMatchObject({
+      code: "USER_NOT_FOUND_ERROR",
+      data: { userId: "u-4" },
+    });
+    await expect(result).rejects.toBeInstanceOf(ORPCError);
+
+    expect(taggedError).toBeInstanceOf(UserNotFoundError);
+  });
+
+  it("preserves tagged error constructors with custom code through eoc.router contracts", async () => {
+    class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
+      schema: z.object({ userId: z.string() }),
+      code: "NOT_FOUND",
+    }) {}
+
+    const routedContract = eoc
+      .errors({
+        UserNotFoundError,
+      })
+      .router({
+        users: {
+          find: oc
+            .input(z.object({ userId: z.string() }))
+            .output(z.object({ userId: z.string() })),
+        },
+      });
+
+    const oe = implementEffect(routedContract, runtime);
+    let taggedError: ORPCError<"NOT_FOUND", { userId: string }> | undefined;
+
+    const procedure = oe.users.find.effect(function* ({ input, errors }) {
+      taggedError = errors.UserNotFoundError({
+        data: { userId: input.userId },
+      });
+      return yield* Effect.fail(taggedError);
+    });
+
+    const result = call(procedure, { userId: "u-4" });
+    await expect(result).rejects.toMatchObject({
+      code: "NOT_FOUND",
+      data: { userId: "u-4" },
+    });
+    await expect(result).rejects.toBeInstanceOf(ORPCError);
+
+    expect(taggedError).toBeInstanceOf(UserNotFoundError);
+  });
+
+  it("retains contract-first restrictions at the type level", () => {
+    const oe = implementEffect(contract, runtime);
+
+    expectTypeOf(oe.users.list.handler).toBeFunction();
+    expectTypeOf(oe.users.list.effect).toBeFunction();
+    // @ts-expect-error input is not a property of the implementer
+    expect(oe.users.list.input).toBeUndefined();
+  });
+
+  it("enforces contract output typing for handlers", () => {
+    const oe = implementEffect(contract, runtime);
+
+    oe.users.list.effect(
+      // @ts-expect-error effect() must return the contract output shape
+      function* () {
+        return { next: "wrong", requestId: 123 };
+      },
+    );
+
+    oe.users.list.handler(
+      // @ts-expect-error handler() must return the contract output shape
+      () => ({ next: "wrong", requestId: 123 }),
+    );
+
+    const procedure = oe.users.list.effect(function* ({ input }) {
+      return {
+        next: input.amount + 1,
+        requestId: "req-ok",
+      };
+    });
+
+    type ProcedureOutput = InferSchemaOutput<
+      NonNullable<(typeof procedure)["~orpc"]["outputSchema"]>
+    >;
+    expectTypeOf<ProcedureOutput>().toEqualTypeOf<{
+      next: number;
+      requestId: string;
+    }>();
+  });
+});

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

@@ -0,0 +1,253 @@
+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 { 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"];
+  customBuilderLike(label: string): any;
+  customValue(): unknown;
+} {
+  return {
+    "~orpc": {
+      ...os["~orpc"],
+      meta,
+    },
+    customBuilderLike(this: any, label: string) {
+      return makeCustomBuilder({
+        ...(this["~orpc"].meta as Record<string, unknown>),
+        label,
+      });
+    },
+    customValue(this: any) {
+      return this["~orpc"].meta;
+    },
+  };
+}
+
+describe("effectBuilder proxy compatibility", () => {
+  it("preserves instanceof and virtual reflection surface", () => {
+    const builder = makeEffectORPC(runtime);
+
+    expect(builder).toBeInstanceOf(EffectBuilder);
+    expect("~orpc" in builder).toBe(true);
+    expect("~effect" in builder).toBe(true);
+    expect("errors" in builder).toBe(true);
+    expect("effect" in builder).toBe(true);
+    expect("traced" in builder).toBe(true);
+    expect("handler" in builder).toBe(true);
+    expect("router" in builder).toBe(true);
+    expect("lazy" in builder).toBe(true);
+    expect("middleware" in builder).toBe(true);
+
+    expect(Object.keys(builder)).toEqual(
+      expect.arrayContaining(["~effect", "~orpc"]),
+    );
+    expect(Reflect.ownKeys(builder)).toEqual(
+      expect.arrayContaining([
+        "~effect",
+        "~orpc",
+        "errors",
+        "effect",
+        "traced",
+        "handler",
+        "router",
+        "lazy",
+      ]),
+    );
+
+    expect(Object.prototype.hasOwnProperty.call(builder, "~orpc")).toBe(true);
+    expect(Object.prototype.hasOwnProperty.call(builder, "~effect")).toBe(true);
+    expect(Object.prototype.hasOwnProperty.call(builder, "effect")).toBe(true);
+
+    const orpcDescriptor = Object.getOwnPropertyDescriptor(builder, "~orpc");
+    expect(orpcDescriptor?.enumerable).toBe(true);
+    expect(orpcDescriptor?.value).toBe(builder["~orpc"]);
+
+    const effectDescriptor = Object.getOwnPropertyDescriptor(
+      builder,
+      "~effect",
+    );
+    expect(effectDescriptor?.enumerable).toBe(true);
+    expect(effectDescriptor?.value).toStrictEqual(builder["~effect"]);
+
+    const methodDescriptor = Object.getOwnPropertyDescriptor(builder, "effect");
+    expect(methodDescriptor?.enumerable).toBe(false);
+    expect(methodDescriptor?.value).toBeTypeOf("function");
+  });
+
+  it("keeps extracted forwarded and intercepted methods callable", () => {
+    const builder = makeEffectORPC(runtime).$meta({ mode: "dev" });
+
+    const meta = builder.meta;
+    const prefixed = builder.prefix;
+    const effect = builder.effect;
+
+    const withMeta = meta({ log: true } as any);
+    const withPrefix = prefixed("/api");
+    const procedure = effect(function* () {
+      return "ok";
+    });
+
+    expect(withMeta).toBeInstanceOf(EffectBuilder);
+    expect(withMeta["~effect"].meta).toEqual({ mode: "dev", log: true });
+    expect(withPrefix).toBeInstanceOf(EffectBuilder);
+    expect((withPrefix as any)["~effect"].prefix).toBe("/api");
+    expect(procedure).toBeInstanceOf(EffectDecoratedProcedure);
+  });
+
+  it("preserves wrapped chaining across forwarded and intercepted methods", () => {
+    const routedBuilder = makeEffectORPC(runtime).prefix("/api").tag("users");
+    const builder = makeEffectORPC(runtime)
+      .$meta({ scope: "users" })
+      .errors({ BAD_REQUEST: { message: "bad request" } })
+      .traced("users.list")
+      .input(z.object({ id: z.string() }))
+      .output(z.object({ id: z.string() }));
+
+    expect(routedBuilder).toBeInstanceOf(EffectBuilder);
+    expect((routedBuilder as any)["~effect"].prefix).toBe("/api");
+    expect((routedBuilder as any)["~effect"].tags).toEqual(["users"]);
+    expect(builder).toBeInstanceOf(EffectBuilder);
+    expect(builder["~effect"].meta).toEqual({ scope: "users" });
+    expect(builder["~effect"].spanConfig?.name).toBe("users.list");
+
+    const procedure = builder.handler(
+      ({ input }: { input: { id: string } }) => input,
+    );
+    expect(procedure).toBeInstanceOf(EffectDecoratedProcedure);
+    expect(procedure["~effect"].runtime).toBe(runtime);
+  });
+
+  it("preserves tagged class support in errors()", () => {
+    class UserNotFoundError extends ORPCTaggedError("UserNotFoundError", {
+      code: "NOT_FOUND",
+      schema: z.object({ userId: z.string() }),
+    }) {}
+
+    const builder = makeEffectORPC(runtime).errors({
+      UserNotFoundError,
+    });
+
+    expect(builder["~effect"].effectErrorMap.UserNotFoundError).toBe(
+      UserNotFoundError,
+    );
+    expect(builder["~orpc"].errorMap).toHaveProperty("NOT_FOUND");
+  });
+
+  it("keeps handler, effect, router, and lazy return behavior unchanged", async () => {
+    const builder = makeEffectORPC(runtime);
+    const procedure = builder.effect(function* () {
+      return { output: "pong" };
+    });
+
+    const handled = builder.handler(() => "handled");
+    const effected = builder.effect(function* () {
+      return "effected";
+    });
+    const routed = builder.prefix("/v1").router({ ping: procedure });
+    const lazied = builder.lazy(async () => ({ default: { ping: procedure } }));
+
+    expect(handled).toBeInstanceOf(EffectDecoratedProcedure);
+    expect(effected).toBeInstanceOf(EffectDecoratedProcedure);
+    expect(routed.ping["~effect"].runtime).toBe(runtime);
+    expect(isLazy(lazied)).toBe(true);
+
+    const { default: resolved } = await unlazy(lazied as any);
+    expect(resolved.ping["~effect"].runtime).toBe(runtime);
+  });
+
+  it("preserves decorated procedure proxy reflection and extracted methods", () => {
+    const procedure = makeEffectORPC(runtime)
+      .route({ path: "/users" })
+      .handler(({ input }) => input);
+
+    expect(procedure).toBeInstanceOf(EffectDecoratedProcedure);
+    expect("~orpc" in procedure).toBe(true);
+    expect("~effect" in procedure).toBe(true);
+    expect("errors" in procedure).toBe(true);
+    expect("meta" in procedure).toBe(true);
+    expect("route" in procedure).toBe(true);
+    expect("use" in procedure).toBe(true);
+    expect("callable" in procedure).toBe(true);
+    expect("actionable" in procedure).toBe(true);
+
+    expect(Reflect.ownKeys(procedure)).toEqual(
+      expect.arrayContaining([
+        "~orpc",
+        "~effect",
+        "errors",
+        "meta",
+        "route",
+        "use",
+        "callable",
+        "actionable",
+      ]),
+    );
+
+    const meta = procedure.meta;
+    const route = procedure.route;
+    const errors = procedure.errors;
+
+    expect(meta({ scope: "users" } as any)["~effect"].meta).toEqual({
+      scope: "users",
+    });
+    expect(route({ method: "GET" })["~effect"].route).toEqual({
+      method: "GET",
+      path: "/users",
+    });
+    const withError = errors({ BAD_REQUEST: { message: "bad request" } });
+    expect(withError["~orpc"].errorMap.BAD_REQUEST.message).toBe("bad request");
+  });
+
+  it("keeps callable procedure clients executable while exposing the procedure surface", async () => {
+    const procedure = makeEffectORPC(runtime).handler(({ input }) => ({
+      echoed: input,
+    }));
+
+    const callable = procedure.callable();
+
+    await expect(callable("hello")).resolves.toEqual({ echoed: "hello" });
+    expect(callable).toSatisfy(isProcedure);
+    expect(callable["~effect"].runtime).toBe(runtime);
+    expect(callable.route({ path: "/echo" })).toBeInstanceOf(
+      EffectDecoratedProcedure,
+    );
+  });
+
+  it("applies builder route and middleware enhancements to routed procedures", () => {
+    const builder = makeEffectORPC(runtime);
+    const middleware = builder.middleware(({ next }) => next({}));
+    const procedure = builder.route({ path: "/ping" }).handler(() => "pong");
+
+    const routed = builder.use(middleware).prefix("/api").router({ procedure });
+
+    expect(routed.procedure["~orpc"].route.path).toBe("/api/ping");
+    expect(routed.procedure["~effect"].route.path).toBe("/api/ping");
+    expect(routed.procedure["~orpc"].middlewares).toHaveLength(
+      procedure["~orpc"].middlewares.length + 1,
+    );
+    expect(routed.procedure["~effect"].middlewares).toHaveLength(
+      procedure["~effect"].middlewares.length + 1,
+    );
+  });
+
+  it("rewraps unknown builder-like methods and passes through non-builder results", () => {
+    const builder = makeEffectORPC(runtime, makeCustomBuilder() as any) as any;
+
+    const customBuilderLike = builder.customBuilderLike;
+    const customValue = builder.customValue;
+
+    const next = customBuilderLike("proxy");
+
+    expect(next).toBeInstanceOf(EffectBuilder);
+    expect(next["~effect"].meta).toEqual({ label: "proxy" });
+    expect(customValue()).toEqual({});
+    expect(next.customValue()).toEqual({ label: "proxy" });
+  });
+});

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

@@ -50,8 +50,12 @@ describe("effectErrorMap types", () => {
   });
 
   it("should infer correct union type from EffectErrorMap", () => {
+    const zBadRequestData = z.object({
+      status: z.number(),
+      message: z.string(),
+    });
     type TestErrorMap = {
-      BAD_REQUEST: { status?: number; message?: string };
+      BAD_REQUEST: { data: typeof zBadRequestData };
       USER_NOT_FOUND_ERROR: typeof UserNotFoundError;
       FORBIDDEN: typeof PermissionDenied;
     };
@@ -59,8 +63,8 @@ describe("effectErrorMap types", () => {
     type ErrorUnion = EffectErrorMapToUnion<TestErrorMap>;
 
     // The union should include ORPCError for traditional and tagged error instances for classes
-    expectTypeOf<ErrorUnion>().toMatchTypeOf<
-      | ORPCError<"BAD_REQUEST", unknown>
+    expectTypeOf<ErrorUnion>().toExtend<
+      | ORPCError<"BAD_REQUEST", typeof zBadRequestData>
       | ORPCTaggedErrorInstance<"UserNotFoundError", "USER_NOT_FOUND_ERROR">
       | ORPCTaggedErrorInstance<"PermissionDenied", "FORBIDDEN">
     >();
@@ -84,6 +88,21 @@ describe("isORPCTaggedErrorClass", () => {
 });
 
 describe("createEffectErrorConstructorMap", () => {
+  it("preserves declaration keys even when a tagged error class uses a different code", () => {
+    const errorMap = {
+      NOT_FOUND: UserNotFoundError,
+    } satisfies EffectErrorMap;
+
+    const constructorMap = createEffectErrorConstructorMap(errorMap);
+    const userNotFoundError = constructorMap.NOT_FOUND({
+      data: { userId: "123" },
+    });
+
+    expect(constructorMap).not.toHaveProperty("USER_NOT_FOUND_ERROR");
+    expect(userNotFoundError).toBeInstanceOf(UserNotFoundError);
+    expect(userNotFoundError.code).toBe("USER_NOT_FOUND_ERROR");
+  });
+
   it("should pass through tagged error classes", () => {
     const errorMap = {
       USER_NOT_FOUND_ERROR: UserNotFoundError,

package/src/tests/parity-shared.ts

@@ -0,0 +1,32 @@
+import { Layer, ManagedRuntime } from "effect";
+
+import { eoc } from "../index";
+import {
+  baseErrorMap,
+  baseMeta,
+  inputSchema,
+  outputSchema,
+  pong,
+} from "./shared";
+
+export type InitialContext = { db: string };
+export type CurrentContext = InitialContext & { auth: boolean };
+
+export const runtime = ManagedRuntime.make(Layer.empty);
+
+export const typedContract = {
+  ping: eoc
+    .errors(baseErrorMap)
+    .meta(baseMeta)
+    .input(inputSchema)
+    .output(outputSchema),
+  pong,
+  nested: {
+    ping: eoc
+      .errors(baseErrorMap)
+      .meta(baseMeta)
+      .input(inputSchema)
+      .output(outputSchema),
+    pong,
+  },
+};