effect-orpc 0.1.4 → 0.2.1

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

package/src/tests/parity.implementer-variants.test.ts

@@ -0,0 +1,249 @@
+import type { Client, ORPCError } from "@orpc/client";
+import type { ErrorFromErrorMap } from "@orpc/contract";
+import type {
+  ActionableClient,
+  ActionableError,
+  ImplementedProcedure,
+  Middleware,
+  MiddlewareOutputFn,
+  ProcedureImplementer,
+} from "@orpc/server";
+import { describe, expectTypeOf, it } from "vitest";
+
+import { implementEffect } from "../index";
+import type { InitialContext } from "./parity-shared";
+import { runtime, typedContract } from "./parity-shared";
+import {
+  type AssertExtends,
+  baseErrorMap,
+  type BaseMeta,
+  inputSchema,
+  outputSchema,
+} from "./shared";
+
+const implementer = implementEffect(typedContract, runtime)
+  .$context<InitialContext>()
+  .use(({ next }) => next({ context: { auth: true as boolean } }));
+
+describe("parity: @orpc/server implementer-procedure.test-d.ts", () => {
+  const builder = implementer.ping;
+
+  it("backward compatibility", () => {
+    expectTypeOf<keyof typeof builder>().toEqualTypeOf<
+      "~orpc" | "handler" | "use" | "effect"
+    >();
+  });
+
+  it("is a contract procedure", () => {
+    expectTypeOf(builder["~orpc"]).toBeObject();
+  });
+
+  it("extends the matching upstream implementer interface", () => {
+    expectTypeOf<
+      AssertExtends<
+        typeof builder,
+        ProcedureImplementer<
+          InitialContext & Record<never, never>,
+          InitialContext & { auth: boolean },
+          typeof inputSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+        >
+      >
+    >().toEqualTypeOf<true>();
+  });
+
+  describe(".use", () => {
+    it("without map input", () => {
+      expectTypeOf(
+        builder.use(
+          (
+            { context, next, path, procedure, errors, signal },
+            input,
+            output,
+          ) => {
+            expectTypeOf(input).toEqualTypeOf<{ input: string }>();
+            expectTypeOf(context).toEqualTypeOf<
+              InitialContext & { auth: boolean }
+            >();
+            expectTypeOf(path).toExtend<readonly string[]>();
+            expectTypeOf(procedure).toBeObject();
+            expectTypeOf(output).toBeFunction();
+            expectTypeOf<
+              AssertExtends<
+                ReturnType<typeof errors.BASE>,
+                ORPCError<"BASE", { output: number }>
+              >
+            >().toEqualTypeOf<true>();
+            expectTypeOf<
+              AssertExtends<
+                ReturnType<typeof errors.OVERRIDE>,
+                ORPCError<"OVERRIDE", any>
+              >
+            >().toEqualTypeOf<true>();
+            expectTypeOf(signal).toExtend<AbortSignal | undefined>();
+
+            return next({ context: { extra: true } });
+          },
+        ),
+      ).toBeObject();
+
+      builder.use(
+        // @ts-expect-error - invalid TInContext
+        {} as Middleware<{ auth: "invalid" }, any, any, any, any, any>,
+      );
+      // @ts-expect-error - input is not match
+      builder.use(({ next }, _input: "invalid") => next({}));
+      // @ts-expect-error - output is not match
+      builder.use(({ next }, _input, _output: MiddlewareOutputFn<"invalid">) =>
+        next({}),
+      );
+      // @ts-expect-error - conflict context
+      builder.use(({ next }) => next({ context: { db: undefined } }));
+    });
+
+    it("with map input", () => {
+      expectTypeOf(
+        builder.use(
+          (
+            { context, next, path, procedure, errors, signal },
+            input: { mapped: boolean },
+            output,
+          ) => {
+            expectTypeOf(input).toEqualTypeOf<{ mapped: boolean }>();
+            expectTypeOf(context).toEqualTypeOf<
+              InitialContext & { auth: boolean }
+            >();
+            expectTypeOf(path).toExtend<readonly string[]>();
+            expectTypeOf(procedure).toBeObject();
+            expectTypeOf(output).toBeFunction();
+            expectTypeOf<
+              AssertExtends<
+                ReturnType<typeof errors.BASE>,
+                ORPCError<"BASE", { output: number }>
+              >
+            >().toEqualTypeOf<true>();
+            expectTypeOf<
+              AssertExtends<
+                ReturnType<typeof errors.OVERRIDE>,
+                ORPCError<"OVERRIDE", any>
+              >
+            >().toEqualTypeOf<true>();
+            expectTypeOf(signal).toExtend<AbortSignal | undefined>();
+
+            return next({ context: { extra: true } });
+          },
+          (input) => {
+            expectTypeOf(input).toEqualTypeOf<{ input: string }>();
+            return { mapped: true };
+          },
+        ),
+      ).toBeObject();
+    });
+
+    it("with TInContext", () => {
+      const mid = {} as Middleware<
+        { cacheable?: boolean } & Record<never, never>,
+        Record<never, never>,
+        unknown,
+        any,
+        any,
+        BaseMeta
+      >;
+
+      expectTypeOf(builder.use(mid)).toBeObject();
+    });
+  });
+
+  it(".handler returns an implemented procedure", () => {
+    const handled = builder.handler(
+      ({ input, context, procedure, path, signal, errors }) => {
+        expectTypeOf(input).toEqualTypeOf<{ input: string }>();
+        expectTypeOf(context).toEqualTypeOf<
+          InitialContext & { auth: boolean }
+        >();
+        expectTypeOf(procedure).toBeObject();
+        expectTypeOf(path).toExtend<readonly string[]>();
+        expectTypeOf(signal).toExtend<AbortSignal | undefined>();
+        expectTypeOf<
+          AssertExtends<
+            ReturnType<typeof errors.BASE>,
+            ORPCError<"BASE", { output: number }>
+          >
+        >().toEqualTypeOf<true>();
+        expectTypeOf<
+          AssertExtends<
+            ReturnType<typeof errors.OVERRIDE>,
+            ORPCError<"OVERRIDE", any>
+          >
+        >().toEqualTypeOf<true>();
+
+        return { output: 456 };
+      },
+    );
+
+    expectTypeOf<
+      AssertExtends<
+        typeof handled,
+        ImplementedProcedure<
+          InitialContext & Record<never, never>,
+          InitialContext & { auth: boolean },
+          typeof inputSchema,
+          typeof outputSchema,
+          typeof baseErrorMap,
+          BaseMeta
+        >
+      >
+    >().toEqualTypeOf<true>();
+
+    expectTypeOf(handled.use).toBeFunction();
+    expectTypeOf(handled.callable).toBeFunction();
+    expectTypeOf(handled.actionable).toBeFunction();
+    const callable = handled.callable({
+      context: async (_clientContext: { batch?: boolean }) => ({
+        db: "postgres",
+      }),
+    });
+
+    expectTypeOf<
+      AssertExtends<
+        typeof callable,
+        Client<
+          { batch?: boolean },
+          { input: number },
+          { output: string },
+          ErrorFromErrorMap<typeof baseErrorMap>
+        >
+      >
+    >().toEqualTypeOf<true>();
+
+    const actionable = handled.actionable({
+      context: async (_clientContext: { batch?: boolean }) => ({
+        db: "postgres",
+      }),
+    });
+
+    expectTypeOf<
+      AssertExtends<
+        typeof actionable,
+        ActionableClient<
+          { input: number },
+          { output: string },
+          ActionableError<ErrorFromErrorMap<typeof baseErrorMap>>
+        >
+      >
+    >().toEqualTypeOf<true>();
+  });
+});
+
+describe("parity: @orpc/server implementer-variants.test-d.ts", () => {
+  it("router-level .use returns an internal implementer", () => {
+    const applied = implementer.nested.use(({ next }) =>
+      next({ context: { extra: true } }),
+    );
+
+    expectTypeOf(applied).toBeObject();
+    expectTypeOf(applied.ping.handler).toBeFunction();
+  });
+});

package/src/tests/parity.implementer.test.ts

@@ -0,0 +1,280 @@
+import type { ORPCError } from "@orpc/client";
+import type { Meta, Schema } from "@orpc/contract";
+import type { Middleware, Router } from "@orpc/server";
+import { describe, expect, expectTypeOf, it } from "vitest";
+
+import type {
+  EffectImplementer,
+  EffectImplementerInternal,
+  EffectProcedureImplementer,
+} from "../index";
+import { implementEffect } from "../index";
+import type { CurrentContext, InitialContext } from "./parity-shared";
+import { runtime, typedContract } from "./parity-shared";
+import type { AssertExtends } from "./shared";
+import {
+  baseErrorMap,
+  type BaseMeta,
+  inputSchema,
+  outputSchema,
+} from "./shared";
+
+const rootImplementer = implementEffect(typedContract, runtime);
+const implementer = rootImplementer
+  .$context<InitialContext>()
+  .use(({ next }) => next({ context: { auth: true as boolean } }));
+
+describe("parity: @orpc/server implementer.test-d.ts", () => {
+  describe("root level", () => {
+    it(".$context", () => {
+      expectTypeOf(rootImplementer.$context<{ anything: string }>()).toExtend<
+        EffectImplementer<
+          typeof typedContract,
+          { anything: string } & Record<never, never>,
+          { anything: string },
+          never,
+          never
+        >
+      >();
+    });
+
+    it(".$config", () => {
+      expectTypeOf(
+        rootImplementer.$config({
+          initialInputValidationIndex: Number.NEGATIVE_INFINITY,
+        }),
+      ).toExtend<
+        EffectImplementer<
+          typeof typedContract,
+          Record<never, never>,
+          Record<never, never>,
+          never,
+          never
+        >
+      >();
+    });
+  });
+
+  describe("router level", () => {
+    it(".middleware", () => {
+      expectTypeOf(
+        rootImplementer
+          .$context<InitialContext>()
+          .nested.middleware(
+            (
+              { context, next, path, procedure, errors, signal },
+              input,
+              output,
+            ) => {
+              expectTypeOf(context).toExtend<InitialContext>();
+              expectTypeOf(input).toEqualTypeOf<unknown>();
+              expectTypeOf(path).toExtend<readonly string[]>();
+              expectTypeOf(procedure).toBeObject();
+              expectTypeOf(output).toBeFunction();
+              expectTypeOf(errors).toBeObject();
+              expectTypeOf(signal).toExtend<AbortSignal | undefined>();
+
+              return next({ context: { extra: true } });
+            },
+          ),
+      ).toBeObject();
+    });
+
+    it(".use", () => {
+      expectTypeOf(
+        implementer.nested.use(
+          (
+            { context, next, path, procedure, errors, signal },
+            input,
+            output,
+          ) => {
+            expectTypeOf(context).toEqualTypeOf<CurrentContext>();
+            expectTypeOf(input).toEqualTypeOf<unknown>();
+            expectTypeOf(path).toExtend<readonly string[]>();
+            expectTypeOf(procedure).toBeObject();
+            expectTypeOf(output).toBeFunction();
+            expectTypeOf(errors).toBeObject();
+            expectTypeOf(signal).toExtend<AbortSignal | undefined>();
+
+            return next({ context: { extra: true } });
+          },
+        ),
+      ).toBeObject();
+
+      const mid = {} as Middleware<
+        { cacheable?: boolean } & Record<never, never>,
+        Record<never, never>,
+        unknown,
+        unknown,
+        any,
+        BaseMeta
+      >;
+
+      expectTypeOf(implementer.use(mid)).toExtend<
+        EffectImplementerInternal<
+          typeof typedContract,
+          InitialContext & { cacheable?: boolean },
+          Omit<CurrentContext, never> & Record<never, never>,
+          never,
+          never
+        >
+      >();
+    });
+
+    it(".router / .lazy", () => {
+      const implementedRouter = {
+        ping: implementer.ping.handler(({ input }) => ({
+          output: Number(input.input),
+        })),
+        pong: implementer.pong.handler(() => undefined),
+        nested: {
+          ping: implementer.nested.ping.handler(({ input }) => ({
+            output: Number(input.input),
+          })),
+          pong: implementer.nested.pong.handler(() => undefined),
+        },
+      };
+      const router = implementer.router(implementedRouter);
+
+      expectTypeOf<
+        AssertExtends<
+          typeof router,
+          Router<typeof typedContract, CurrentContext>
+        >
+      >().toEqualTypeOf<true>();
+
+      expectTypeOf(
+        implementer.lazy(async () => ({ default: implementedRouter })),
+      ).toBeObject();
+
+      // @ts-expect-error - meta def is not match
+      implementer.router({ ping: {} });
+
+      // @ts-expect-error - missing implementation
+      implementer.router({ ping: implementedRouter.ping });
+    });
+  });
+
+  it("each procedure is a ProcedureImplementer", () => {
+    type ExpectedPing = EffectProcedureImplementer<
+      InitialContext & Record<never, never>,
+      CurrentContext,
+      typeof inputSchema,
+      typeof outputSchema,
+      typeof baseErrorMap,
+      BaseMeta,
+      never,
+      never
+    >;
+
+    type ExpectedPong = EffectProcedureImplementer<
+      InitialContext & Record<never, never>,
+      CurrentContext,
+      Schema<unknown, unknown>,
+      Schema<unknown, unknown>,
+      Record<never, never>,
+      Meta,
+      never,
+      never
+    >;
+
+    expectTypeOf(implementer.ping).toExtend<ExpectedPing>();
+    expectTypeOf(implementer.nested.ping).toExtend<ExpectedPing>();
+    expectTypeOf(implementer.pong).toExtend<ExpectedPong>();
+    expectTypeOf(implementer.nested.pong).toExtend<ExpectedPong>();
+  });
+
+  it("procedure .use preserves the leaf error map", () => {
+    implementer.ping.use(({ errors, next }) => {
+      expectTypeOf<
+        AssertExtends<
+          ReturnType<typeof errors.BASE>,
+          ORPCError<"BASE", { output: number }>
+        >
+      >().toEqualTypeOf<true>();
+      expectTypeOf<
+        AssertExtends<
+          ReturnType<typeof errors.OVERRIDE>,
+          ORPCError<"OVERRIDE", any>
+        >
+      >().toEqualTypeOf<true>();
+      // @ts-expect-error - leaf middleware errors should not widen to arbitrary keys
+      expect(errors.MISSING).toBeUndefined();
+
+      return next({});
+    });
+
+    implementer.ping.use(
+      ({ errors, next }) => {
+        expectTypeOf<
+          AssertExtends<
+            ReturnType<typeof errors.BASE>,
+            ORPCError<"BASE", { output: number }>
+          >
+        >().toEqualTypeOf<true>();
+        expectTypeOf<
+          AssertExtends<
+            ReturnType<typeof errors.OVERRIDE>,
+            ORPCError<"OVERRIDE", any>
+          >
+        >().toEqualTypeOf<true>();
+        // @ts-expect-error - mapped input overload should keep the same leaf error map
+        expect(errors.MISSING).toBeUndefined();
+
+        return next({});
+      },
+      () => ({ mapped: true }),
+    );
+  });
+
+  it("procedure .handler preserves upstream handler option typing", () => {
+    implementer.ping.handler(
+      ({ context, input, path, procedure, errors, signal }) => {
+        expectTypeOf(context).toExtend<CurrentContext>();
+        expectTypeOf(input).toEqualTypeOf<{ input: string }>();
+        expectTypeOf(path).toExtend<readonly string[]>();
+        expectTypeOf(procedure).toBeObject();
+        expectTypeOf(signal).toExtend<AbortSignal | undefined>();
+        expectTypeOf<
+          AssertExtends<
+            ReturnType<typeof errors.BASE>,
+            ORPCError<"BASE", { output: number }>
+          >
+        >().toEqualTypeOf<true>();
+        expectTypeOf<
+          AssertExtends<
+            ReturnType<typeof errors.OVERRIDE>,
+            ORPCError<"OVERRIDE", any>
+          >
+        >().toEqualTypeOf<true>();
+        // @ts-expect-error - handler errors should not widen beyond the leaf error map
+        expect(errors.MISSING).toBeUndefined();
+
+        return {
+          output: Number(input.input),
+        };
+      },
+    );
+
+    implementer.ping.handler(
+      // @ts-expect-error - handler output must match the contract output shape
+      () => ({ output: "wrong" }),
+    );
+
+    implementer.ping.handler(
+      // @ts-expect-error - handler input should be the parsed contract input
+      ({ input }: { input: { invalid: true } }) => ({
+        output: Number(input.invalid),
+      }),
+    );
+  });
+
+  it("procedure leaves do not expose .middleware", () => {
+    expect(
+      (implementer.ping as { middleware?: unknown }).middleware,
+    ).toBeUndefined();
+    // @ts-expect-error - procedure implementer leaves should not expose middleware
+    expect(implementer.ping.middleware).toBeUndefined();
+    expectTypeOf(implementer.nested).toHaveProperty("middleware");
+  });
+});

package/src/tests/shared.ts

@@ -76,3 +76,5 @@ export const streamed = new ContractProcedure<
   inputSchema,
   outputSchema: streamedOutputSchema,
 });
+
+export type AssertExtends<_TActual extends TExpected, TExpected> = true;