effect-orpc 1.0.0-effect-v4.2 → 1.0.0-effect-v4.4

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

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

@@ -0,0 +1,222 @@
+import { ContractBuilder, isContractProcedure } from "@orpc/contract";
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import { effectErrorMapToErrorMap, eoc } from "../index";
+import {
+  baseErrorMap,
+  baseMeta,
+  baseRoute,
+  generalSchema,
+  inputSchema,
+  outputSchema,
+  ping,
+  pong,
+} from "./shared";
+
+const builder = eoc
+  .$meta(baseMeta)
+  .$route(baseRoute)
+  .$input(inputSchema)
+  .errors(baseErrorMap);
+
+describe("parity: @orpc/contract builder.test.ts", () => {
+  it("is a contract procedure", () => {
+    expect(eoc).toSatisfy(isContractProcedure);
+  });
+
+  it(".$meta", () => {
+    const meta = { dev: true, log: true };
+    const applied = builder.$meta(meta);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      meta,
+    });
+  });
+
+  it(".$route", () => {
+    const route = { method: "GET", path: "/api" } as const;
+    const applied = builder.$route(route);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      route,
+    });
+  });
+
+  it(".$input", () => {
+    const applied = builder.$input(generalSchema);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      inputSchema: generalSchema,
+    });
+  });
+
+  it(".errors", () => {
+    const errors = {
+      BAD_GATEWAY: { data: outputSchema },
+      OVERRIDE: { message: "override" },
+    } as const;
+    const applied = builder.errors(errors);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      errorMap: effectErrorMapToErrorMap({
+        ...baseErrorMap,
+        ...errors,
+      }),
+    });
+  });
+
+  it(".meta", () => {
+    const meta = { dev: true, log: true };
+    const applied = builder.meta(meta);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      meta: { ...builder["~orpc"].meta, ...meta },
+    });
+  });
+
+  it(".route", () => {
+    const route = { method: "GET", path: "/path" } as const;
+    const applied = builder.route(route);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      route: { ...builder["~orpc"].route, ...route },
+    });
+  });
+
+  it(".input", () => {
+    const applied = builder.input(generalSchema);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      inputSchema: generalSchema,
+    });
+  });
+
+  it(".output", () => {
+    const applied = builder.output(generalSchema);
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      outputSchema: generalSchema,
+    });
+  });
+
+  it(".prefix", () => {
+    const applied = builder.prefix("/api") as any;
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      prefix: "/api",
+    });
+  });
+
+  it(".tag", () => {
+    const applied = builder.tag("tag1", "tag2") as any;
+
+    expect(applied).toBeInstanceOf(ContractBuilder);
+    expect(applied).not.toBe(builder);
+    expect(applied["~orpc"]).toEqual({
+      ...builder["~orpc"],
+      tags: ["tag1", "tag2"],
+    });
+  });
+
+  it(".router", () => {
+    const router = builder.router({ ping, pong });
+
+    expect(router.ping["~orpc"].route.path).toBe("/base");
+    expect(router.ping["~orpc"].meta).toEqual(baseMeta);
+    expect(router.ping["~orpc"].errorMap).toEqual(baseErrorMap);
+  });
+});
+
+describe("parity: @orpc/contract builder.test-d.ts", () => {
+  const typedBuilder = builder;
+
+  it("is a contract procedure", () => {
+    expectTypeOf(typedBuilder["~orpc"]).toBeObject();
+  });
+
+  it("preserves ContractBuilder typing for root methods", () => {
+    expectTypeOf(typedBuilder.$meta<{ auth?: boolean }>({})).toBeObject();
+
+    expectTypeOf(typedBuilder.$route({ method: "GET", path: "/api" })).toExtend<
+      typeof typedBuilder
+    >();
+
+    expectTypeOf(typedBuilder.$input(generalSchema)).toBeObject();
+
+    expectTypeOf(
+      typedBuilder.errors({
+        INVALID: { message: "invalid" },
+        OVERRIDE: { message: "override" },
+      }),
+    ).toBeObject();
+
+    expectTypeOf(typedBuilder.meta({ log: true })).toBeObject();
+    expectTypeOf(typedBuilder.route({ method: "GET" })).toBeObject();
+    expectTypeOf(typedBuilder.input(generalSchema)).toBeObject();
+    expectTypeOf(typedBuilder.output(generalSchema)).toBeObject();
+    expectTypeOf(typedBuilder.prefix("/api")).toBeObject();
+    expectTypeOf(typedBuilder.tag("tag1", "tag2")).toBeObject();
+    expectTypeOf(typedBuilder.router({ ping, pong })).toExtend<{
+      ping: typeof ping;
+      pong: typeof pong;
+    }>();
+  });
+
+  it("preserves ContractBuilder constraints", () => {
+    // @ts-expect-error - initial meta is required
+    typedBuilder.$meta<{ auth?: boolean }>();
+    // @ts-expect-error - auth is missing in initial meta
+    typedBuilder.$meta<{ auth: boolean }>({});
+    // @ts-expect-error - invalid method
+    typedBuilder.$route({ method: "INVALID" });
+    // @ts-expect-error - invalid schema
+    typedBuilder.$input({});
+    // @ts-expect-error - schema is invalid
+    typedBuilder.errors({ TOO_MANY_REQUESTS: { data: {} } });
+    // @ts-expect-error - invalid meta
+    typedBuilder.meta({ meta: "INVALID" });
+    // @ts-expect-error - invalid method
+    typedBuilder.route({ method: "INVALID" });
+    // @ts-expect-error - invalid schema
+    typedBuilder.input({});
+    // @ts-expect-error - invalid schema
+    typedBuilder.output({});
+    // @ts-expect-error - invalid prefix
+    typedBuilder.prefix(1);
+    // @ts-expect-error - invalid tag
+    typedBuilder.tag(1);
+  });
+
+  it("keeps eoc-specific tagged error normalization separate", () => {
+    const applied = eoc.errors(baseErrorMap);
+
+    expectTypeOf(applied["~orpc"].errorMap).toBeObject();
+  });
+});

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

@@ -0,0 +1,193 @@
+import type { ContractProcedure, Schema } from "@orpc/contract";
+import type {
+  DecoratedMiddleware,
+  Middleware,
+  MiddlewareOutputFn,
+} from "@orpc/server";
+import type { OmitChainMethodDeep } from "@orpc/shared";
+import { describe, expectTypeOf, it } from "vitest";
+import z from "zod";
+
+import {
+  EffectBuilder,
+  EffectDecoratedProcedure,
+  makeEffectORPC,
+} from "../index";
+import type { CurrentContext, InitialContext } from "./parity-shared";
+import { runtime } from "./parity-shared";
+import type { AssertExtends } from "./shared";
+import {
+  baseErrorMap,
+  baseMeta,
+  type BaseMeta,
+  inputSchema,
+  outputSchema,
+} from "./shared";
+
+const typedBuilder = {} as EffectBuilder<
+  InitialContext,
+  CurrentContext,
+  typeof inputSchema,
+  typeof outputSchema,
+  typeof baseErrorMap,
+  BaseMeta,
+  never,
+  never
+>;
+
+const rootBuilder = makeEffectORPC(runtime)
+  .$context<InitialContext>()
+  .$meta(baseMeta)
+  .$input(inputSchema)
+  .errors(baseErrorMap);
+
+const withMiddlewares = rootBuilder.use(({ next }) =>
+  next({ context: { auth: true as boolean } }),
+);
+
+const procedureBuilder = withMiddlewares.meta(baseMeta);
+const withInput = procedureBuilder.input(inputSchema);
+const withOutput = procedureBuilder.output(outputSchema);
+const withInputOutput = withInput.output(outputSchema);
+
+describe("parity: @orpc/server builder.test-d.ts", () => {
+  it("is a contract procedure", () => {
+    expectTypeOf<
+      AssertExtends<
+        typeof typedBuilder,
+        ContractProcedure<
+          typeof inputSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+        >
+      >
+    >().toEqualTypeOf<true>();
+  });
+
+  it(".$config / .$context / .$meta / .$route / .$input", () => {
+    expectTypeOf(
+      rootBuilder.$config({
+        initialInputValidationIndex: Number.NEGATIVE_INFINITY,
+        initialOutputValidationIndex: Number.POSITIVE_INFINITY,
+      }),
+    ).toBeObject();
+
+    expectTypeOf(rootBuilder.$context()).toBeObject();
+    expectTypeOf(rootBuilder.$context<{ anything: string }>()).toBeObject();
+    expectTypeOf(rootBuilder.$meta<{ auth?: boolean }>({})).toBeObject();
+    expectTypeOf(rootBuilder.$route({ method: "GET" })).toBeObject();
+
+    const schema = z.void();
+    expectTypeOf(rootBuilder.$input(schema)).toBeObject();
+    expectTypeOf(rootBuilder.$input<Schema<void, unknown>>()).toBeObject();
+
+    rootBuilder.$config({
+      // @ts-expect-error - must be number
+      initialInputValidationIndex: "INVALID",
+    });
+    // @ts-expect-error - initial meta is required
+    rootBuilder.$meta<{ auth?: boolean }>();
+    // @ts-expect-error - invalid method
+    rootBuilder.$route({ method: "INVALID" });
+    // @ts-expect-error - invalid schema
+    rootBuilder.$input<"invalid">();
+  });
+
+  it(".middleware", () => {
+    expectTypeOf(
+      rootBuilder.middleware(
+        ({ next }, input: "input", output: MiddlewareOutputFn<"output">) => {
+          expectTypeOf(input).toEqualTypeOf<"input">();
+          expectTypeOf(output).toEqualTypeOf<MiddlewareOutputFn<"output">>();
+          return next({ context: { extra: true } });
+        },
+      ),
+    ).toExtend<
+      DecoratedMiddleware<
+        InitialContext,
+        { extra: boolean },
+        "input",
+        "output",
+        any,
+        BaseMeta
+      >
+    >();
+  });
+
+  it(".errors / .use / .meta / .route / .input / .output", () => {
+    expectTypeOf(
+      rootBuilder.errors({ BAD_GATEWAY: { message: "BAD" } }),
+    ).toBeObject();
+    expectTypeOf(withMiddlewares.use).toBeFunction();
+    expectTypeOf(withMiddlewares.meta).toBeFunction();
+    expectTypeOf(withMiddlewares.route).toBeFunction();
+    expectTypeOf(withMiddlewares.input).toBeFunction();
+    expectTypeOf(withMiddlewares.output).toBeFunction();
+
+    const mid = {} as Middleware<
+      { cacheable?: boolean } & Record<never, never>,
+      Record<never, never>,
+      unknown,
+      unknown,
+      any,
+      BaseMeta
+    >;
+    expectTypeOf(withMiddlewares.use(mid)).toBeObject();
+  });
+
+  it(".handler / .effect / .prefix / .tag / .router / .lazy", () => {
+    expectTypeOf(withOutput.handler(() => ({ output: 456 }))).toExtend<
+      EffectDecoratedProcedure<
+        InitialContext & Record<never, never>,
+        CurrentContext,
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta,
+        never,
+        never
+      >
+    >();
+
+    expectTypeOf(
+      withOutput.effect(function* () {
+        return { output: 456 };
+      }),
+    ).toExtend<
+      EffectDecoratedProcedure<
+        InitialContext & Record<never, never>,
+        CurrentContext,
+        typeof inputSchema,
+        typeof outputSchema,
+        typeof baseErrorMap,
+        BaseMeta,
+        never,
+        never
+      >
+    >();
+
+    expectTypeOf(rootBuilder.prefix("/api")).toBeObject();
+    expectTypeOf(rootBuilder.tag("tag1", "tag2")).toBeObject();
+  });
+});
+
+describe("parity: @orpc/server builder-variants.test-d.ts", () => {
+  it("keeps variant method surface aligned with upstream", () => {
+    void ({} as OmitChainMethodDeep<
+      typeof typedBuilder,
+      "$config" | "$context" | "$meta" | "$route" | "$input" | "middleware"
+    >);
+
+    expectTypeOf(withMiddlewares.errors).toBeFunction();
+    expectTypeOf(withMiddlewares.use).toBeFunction();
+    expectTypeOf(withMiddlewares.handler).toBeFunction();
+    expectTypeOf(withMiddlewares.effect).toBeFunction();
+
+    expectTypeOf(withMiddlewares.handler).toBeFunction();
+    expectTypeOf(procedureBuilder.traced).toBeFunction();
+    expectTypeOf(withInput.output).toBeFunction();
+    expectTypeOf(withOutput.input).toBeFunction();
+    expectTypeOf(withInputOutput.effect).toBeFunction();
+  });
+});