effect-orpc 0.1.3 → 0.2.0

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;

package/src/types/index.ts

@@ -22,7 +22,6 @@ import type {
   ProcedureHandlerOptions,
   RouterBuilder,
 } from "@orpc/server";
-import type { Promisable } from "@orpc/shared";
 import type { Effect, ManagedRuntime } from "effect";
 import type { YieldWrap } from "effect/Utils";
 
@@ -62,21 +61,6 @@ export interface EffectBuilderDef<
   effectErrorMap: TEffectErrorMap;
 }
 
-export type NonEffectProcedureHandler<
-  TCurrentContext extends Context,
-  TInput,
-  THandlerOutput,
-  TEffectErrorMap extends EffectErrorMap,
-  TMeta extends Meta,
-> = (
-  opt: ProcedureHandlerOptions<
-    TCurrentContext,
-    TInput,
-    EffectErrorConstructorMap<TEffectErrorMap>,
-    TMeta
-  >,
-) => Promisable<THandlerOutput>;
-
 /**
  * Extended procedure definition that includes the Effect ManagedRuntime.
  */

package/src/types/variants.ts

@@ -21,6 +21,7 @@ import type {
   MergedCurrentContext,
   MergedInitialContext,
   Middleware,
+  ProcedureHandler,
   Router,
 } from "@orpc/server";
 
@@ -201,12 +202,11 @@ export interface EffectBuilderWithMiddlewares<
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
    */
   "handler"<UFuncOutput>(
-    handler: EffectProcedureHandler<
+    handler: ProcedureHandler<
       TCurrentContext,
       unknown,
       UFuncOutput,
-      TEffectErrorMap,
-      TRequirementsProvided,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
       TMeta
     >,
   ): EffectDecoratedProcedure<
@@ -476,12 +476,11 @@ export interface EffectProcedureBuilder<
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
    */
   "handler"<UFuncOutput>(
-    handler: EffectProcedureHandler<
+    handler: ProcedureHandler<
       TCurrentContext,
       unknown,
       UFuncOutput,
-      TEffectErrorMap,
-      TRequirementsProvided,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
       TMeta
     >,
   ): EffectDecoratedProcedure<
@@ -514,6 +513,19 @@ export interface EffectProcedureBuilder<
     TRequirementsProvided,
     TRuntimeError
   >;
+
+  "traced"(
+    spanName: string,
+  ): EffectProcedureBuilder<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >;
 }
 
 export interface EffectProcedureBuilderWithInput<
@@ -694,12 +706,11 @@ export interface EffectProcedureBuilderWithInput<
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
    */
   "handler"<UFuncOutput>(
-    handler: EffectProcedureHandler<
+    handler: ProcedureHandler<
       TCurrentContext,
       InferSchemaOutput<TInputSchema>,
       UFuncOutput,
-      TEffectErrorMap,
-      TRequirementsProvided,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
       TMeta
     >,
   ): EffectDecoratedProcedure<
@@ -791,7 +802,7 @@ export interface EffectProcedureBuilderWithOutput<
     TCurrentContext,
     TInputSchema,
     TOutputSchema,
-    TEffectErrorMap,
+    MergedEffectErrorMap<TEffectErrorMap, U>,
     TMeta,
     TRequirementsProvided,
     TRuntimeError
@@ -891,12 +902,11 @@ export interface EffectProcedureBuilderWithOutput<
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
    */
   "handler"(
-    handler: EffectProcedureHandler<
+    handler: ProcedureHandler<
       TCurrentContext,
       unknown,
       InferSchemaInput<TOutputSchema>,
-      TEffectErrorMap,
-      TRequirementsProvided,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
       TMeta
     >,
   ): EffectDecoratedProcedure<
@@ -1104,12 +1114,11 @@ export interface EffectProcedureBuilderWithInputOutput<
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}
    */
   "handler"(
-    handler: EffectProcedureHandler<
+    handler: ProcedureHandler<
       TCurrentContext,
       InferSchemaOutput<TInputSchema>,
       InferSchemaInput<TOutputSchema>,
-      TEffectErrorMap,
-      TRequirementsProvided,
+      EffectErrorMapToErrorMap<TEffectErrorMap>,
       TMeta
     >,
   ): EffectDecoratedProcedure<