effect-orpc 0.1.4 → 0.2.0

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-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,
+  },
+};

package/src/tests/parity.contract-builder-variants.test.ts

@@ -0,0 +1,192 @@
+import type { OmitChainMethodDeep } from "@orpc/shared";
+import { describe, expectTypeOf, it } from "vitest";
+
+import type {
+  EffectContractProcedureBuilderWithInputOutput,
+  EffectContractRouterBuilder,
+} from "../index";
+import { eoc } from "../index";
+import {
+  type BaseMeta,
+  baseErrorMap,
+  generalSchema,
+  inputSchema,
+  outputSchema,
+  ping,
+  pong,
+} from "./shared";
+
+const generalBuilder = eoc
+  .$meta({ mode: "dev" } as BaseMeta)
+  .$input(inputSchema)
+  .errors(baseErrorMap);
+
+describe("parity: @orpc/contract builder-variants.test-d.ts", () => {
+  describe("EffectContractProcedureBuilder", () => {
+    const builder = eoc.errors(baseErrorMap).meta({ mode: "dev" } as BaseMeta);
+
+    it("backward compatibility", () => {
+      const expected = {} as OmitChainMethodDeep<
+        typeof generalBuilder,
+        "$meta" | "$route" | "$input" | "prefix" | "tag" | "router"
+      >;
+
+      expectTypeOf<keyof typeof builder>().toEqualTypeOf<
+        keyof typeof expected
+      >();
+    });
+
+    it(".errors / .meta / .route / .input / .output", () => {
+      expectTypeOf(
+        builder.errors({ INVALID: { message: "invalid" } }),
+      ).toBeObject();
+      expectTypeOf(builder.meta({ log: true })).toBeObject();
+      expectTypeOf(builder.route({ method: "GET" })).toBeObject();
+      expectTypeOf(builder.input(generalSchema)).toBeObject();
+      expectTypeOf(builder.output(generalSchema)).toBeObject();
+
+      // @ts-expect-error - schema is invalid
+      builder.errors({ TOO_MANY_REQUESTS: { data: {} } });
+      // @ts-expect-error - invalid method
+      builder.route({ method: "INVALID" });
+      // @ts-expect-error - schema is invalid
+      builder.input({});
+      // @ts-expect-error - schema is invalid
+      builder.output({});
+    });
+  });
+
+  describe("EffectContractProcedureBuilderWithInput", () => {
+    const builder = eoc
+      .errors(baseErrorMap)
+      .meta({ mode: "dev" })
+      .input(inputSchema);
+
+    it("backward compatibility", () => {
+      const expected = {} as OmitChainMethodDeep<
+        typeof generalBuilder,
+        "$meta" | "$route" | "$input" | "prefix" | "tag" | "router" | "input"
+      >;
+
+      expectTypeOf<keyof typeof builder>().toEqualTypeOf<
+        keyof typeof expected
+      >();
+    });
+
+    it(".errors / .meta / .route / .output", () => {
+      expectTypeOf(
+        builder.errors({ INVALID: { message: "invalid" } }),
+      ).toBeObject();
+      expectTypeOf(builder.meta({ log: true })).toBeObject();
+      expectTypeOf(builder.route({ method: "GET" })).toBeObject();
+      expectTypeOf(builder.output(generalSchema)).toExtend<
+        EffectContractProcedureBuilderWithInputOutput<
+          typeof inputSchema,
+          typeof generalSchema,
+          typeof baseErrorMap,
+          BaseMeta
+        >
+      >();
+    });
+  });
+
+  describe("EffectContractProcedureBuilderWithOutput", () => {
+    const builder = eoc
+      .errors(baseErrorMap)
+      .meta({ mode: "dev" })
+      .output(outputSchema);
+
+    it("backward compatibility", () => {
+      const expected = {} as OmitChainMethodDeep<
+        typeof generalBuilder,
+        "$meta" | "$route" | "$input" | "prefix" | "tag" | "router" | "output"
+      >;
+
+      expectTypeOf<keyof typeof builder>().toEqualTypeOf<
+        keyof typeof expected
+      >();
+    });
+
+    it(".errors / .meta / .route / .input", () => {
+      expectTypeOf(
+        builder.errors({ INVALID: { message: "invalid" } }),
+      ).toBeObject();
+      expectTypeOf(builder.meta({ log: true })).toBeObject();
+      expectTypeOf(builder.route({ method: "GET" })).toBeObject();
+      expectTypeOf(builder.input(generalSchema)).toExtend<
+        EffectContractProcedureBuilderWithInputOutput<
+          typeof generalSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+        >
+      >();
+    });
+  });
+
+  describe("EffectContractProcedureBuilderWithInputOutput", () => {
+    const builder = eoc
+      .errors(baseErrorMap)
+      .meta({ mode: "dev" })
+      .input(inputSchema)
+      .output(outputSchema);
+
+    it("backward compatibility", () => {
+      const expected = {} as OmitChainMethodDeep<
+        typeof generalBuilder,
+        | "$meta"
+        | "$route"
+        | "$input"
+        | "prefix"
+        | "tag"
+        | "router"
+        | "input"
+        | "output"
+      >;
+
+      expectTypeOf<keyof typeof builder>().toEqualTypeOf<
+        keyof typeof expected
+      >();
+    });
+
+    it(".errors / .meta / .route", () => {
+      expectTypeOf(
+        builder.errors({ INVALID: { message: "invalid" } }),
+      ).toBeObject();
+      expectTypeOf(builder.meta({ log: true })).toBeObject();
+      expectTypeOf(builder.route({ method: "GET" })).toBeObject();
+    });
+  });
+
+  describe("EffectContractRouterBuilder", () => {
+    const builder = eoc.errors(baseErrorMap).prefix("/api");
+
+    it("backward compatibility", () => {
+      expectTypeOf(builder.errors).toBeFunction();
+      expectTypeOf(builder.prefix).toBeFunction();
+      expectTypeOf(builder.tag).toBeFunction();
+      expectTypeOf(builder.router).toBeFunction();
+    });
+
+    it(".errors / .prefix / .tag / .router", () => {
+      expectTypeOf(
+        builder.errors({ INVALID: { message: "invalid" } }),
+      ).toBeObject();
+      expectTypeOf(builder.prefix("/api")).toExtend<
+        EffectContractRouterBuilder<typeof baseErrorMap, BaseMeta>
+      >();
+      expectTypeOf(builder.tag("tag1", "tag2")).toExtend<
+        EffectContractRouterBuilder<typeof baseErrorMap, BaseMeta>
+      >();
+      expectTypeOf(builder.router({ ping, pong })).toExtend<{
+        ping: typeof ping;
+        pong: typeof pong;
+      }>();
+
+      // @ts-expect-error - invalid prefix
+      builder.prefix(1);
+      // @ts-expect-error - invalid tag
+      builder.tag(1);
+    });
+  });
+});