effect-orpc 0.1.3 → 0.2.0

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

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

@@ -0,0 +1,124 @@
+import type { Middleware, MiddlewareOutputFn, Procedure } from "@orpc/server";
+import { describe, expectTypeOf, it } from "vitest";
+
+import { makeEffectORPC } from "../index";
+import type { CurrentContext, InitialContext } from "./parity-shared";
+import { runtime } from "./parity-shared";
+import {
+  type AssertExtends,
+  baseErrorMap,
+  type BaseMeta,
+  inputSchema,
+  outputSchema,
+} from "./shared";
+
+const procedure = makeEffectORPC(runtime)
+  .$context<InitialContext>()
+  .$meta({ mode: "dev" } as BaseMeta)
+  .$input(inputSchema)
+  .errors(baseErrorMap)
+  .use(({ next }) => next({ context: { auth: true as boolean } }))
+  .output(outputSchema)
+  .effect(function* () {
+    return { output: 456 };
+  });
+
+describe("parity: @orpc/server procedure-decorated.test-d.ts", () => {
+  it("is a procedure", () => {
+    expectTypeOf<
+      AssertExtends<
+        typeof procedure,
+        Procedure<
+          InitialContext & Record<never, never>,
+          CurrentContext,
+          typeof inputSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+        >
+      >
+    >().toEqualTypeOf<true>();
+  });
+
+  it(".errors / .meta / .route", () => {
+    expectTypeOf(
+      procedure.errors({
+        BAD_GATEWAY: { message: "BAD_GATEWAY" },
+        OVERRIDE: { message: "OVERRIDE" },
+      }),
+    ).toBeObject();
+
+    expectTypeOf(procedure.meta({ mode: "dev", log: true })).toBeObject();
+    expectTypeOf(
+      procedure.route({ method: "POST", path: "/v2/users", tags: ["tag"] }),
+    ).toBeObject();
+
+    // @ts-expect-error - invalid meta
+    procedure.meta({ log: "INVALID" });
+    // @ts-expect-error - invalid method
+    procedure.route({ method: "INVALID" });
+  });
+
+  describe(".use", () => {
+    it("without map input", () => {
+      expectTypeOf(
+        procedure.use(({ next }, input, output) => {
+          expectTypeOf(input).toEqualTypeOf<{ input: string }>();
+          expectTypeOf(output).toBeFunction();
+          return next({ context: { extra: true } });
+        }),
+      ).toBeObject();
+
+      procedure.use(
+        // @ts-expect-error - invalid TInContext
+        {} as Middleware<{ auth: "invalid" }, any, any, any, any, any>,
+      );
+      // @ts-expect-error - input is not match
+      procedure.use(({ next }, _input: "invalid") => next({}));
+      procedure.use(
+        // @ts-expect-error - output is not match
+        ({ next }, _input, _output: MiddlewareOutputFn<"invalid">) => next({}),
+      );
+      // @ts-expect-error - conflict context
+      procedure.use(({ next }) => next({ context: { db: undefined } }));
+    });
+
+    it("with map input", () => {
+      expectTypeOf(
+        procedure.use(
+          ({ next }, input: { mapped: string }, output) => {
+            expectTypeOf(input).toEqualTypeOf<{ mapped: string }>();
+            expectTypeOf(output).toBeFunction();
+            return next({ context: { extra: true } });
+          },
+          (input) => ({ mapped: input.input }),
+        ),
+      ).toBeObject();
+    });
+  });
+
+  it(".callable / .actionable", () => {
+    expectTypeOf(
+      procedure.callable({
+        context: async (_clientContext: { batch?: boolean }) => ({
+          db: "postgres",
+        }),
+      }),
+    ).toBeFunction();
+
+    expectTypeOf(
+      procedure.actionable({
+        context: async (_clientContext: { batch?: boolean }) => ({
+          db: "postgres",
+        }),
+      }),
+    ).toBeFunction();
+
+    procedure.actionable({
+      // @ts-expect-error - all clientContext must be optional
+      context: async (_clientContext: { batch: boolean }) => ({
+        db: "postgres",
+      }),
+    });
+  });
+});