effect-orpc 0.2.2 → 0.4.0

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

@@ -4,6 +4,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 import z from "zod";
 
 import { EffectDecoratedProcedure } from "../effect-procedure";
+import { makeEffectRuntimeRunner } from "../runtime-source";
 import {
   baseErrorMap,
   baseMeta,
@@ -25,6 +26,7 @@ vi.mock("@orpc/server", async (importOriginal) => {
 });
 
 const runtime = ManagedRuntime.make(Layer.empty);
+const runner = makeEffectRuntimeRunner(runtime);
 
 const handler = vi.fn();
 const middleware = vi.fn();
@@ -40,6 +42,7 @@ const def = {
   meta: baseMeta,
   route: baseRoute,
   handler,
+  runner,
   runtime,
 };
 
@@ -80,7 +83,7 @@ describe("effectDecoratedProcedure", () => {
     });
 
     // Preserves runtime
-    expect(applied["~effect"].runtime).toBe(runtime);
+    expect(applied["~effect"].runner.runtime).toBe(runtime);
   });
 
   it(".meta", () => {
@@ -96,7 +99,7 @@ describe("effectDecoratedProcedure", () => {
     });
 
     // Preserves runtime
-    expect(applied["~effect"].runtime).toBe(runtime);
+    expect(applied["~effect"].runner.runtime).toBe(runtime);
   });
 
   it(".route", () => {
@@ -112,7 +115,7 @@ describe("effectDecoratedProcedure", () => {
     });
 
     // Preserves runtime
-    expect(applied["~effect"].runtime).toBe(runtime);
+    expect(applied["~effect"].runner.runtime).toBe(runtime);
   });
 
   describe(".use", () => {
@@ -129,7 +132,7 @@ describe("effectDecoratedProcedure", () => {
       });
 
       // Preserves runtime
-      expect(applied["~effect"].runtime).toBe(runtime);
+      expect(applied["~effect"].runner.runtime).toBe(runtime);
     });
 
     it("with map input", () => {
@@ -146,7 +149,7 @@ describe("effectDecoratedProcedure", () => {
       });
 
       // Preserves runtime
-      expect(applied["~effect"].runtime).toBe(runtime);
+      expect(applied["~effect"].runner.runtime).toBe(runtime);
     });
   });
 
@@ -207,7 +210,7 @@ describe("effectDecoratedProcedure chaining", () => {
       .route({ path: "/custom" });
 
     expect(applied).toBeInstanceOf(EffectDecoratedProcedure);
-    expect(applied["~effect"].runtime).toBe(runtime);
+    expect(applied["~effect"].runner.runtime).toBe(runtime);
     expect(applied["~effect"].errorMap).toHaveProperty("CUSTOM");
   });
 });

package/src/tests/node-side-effect.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi } from "vitest";
+
+async function makeSplitProcedure(options: {
+  readonly installNodeBridge: boolean;
+}) {
+  vi.resetModules();
+
+  if (options.installNodeBridge) {
+    await import("../node");
+  } else {
+    const { installFiberContextBridge } =
+      await import("../fiber-context-bridge");
+    installFiberContextBridge(undefined);
+  }
+
+  const [
+    { call },
+    { Context, Effect, Layer, ManagedRuntime },
+    { makeEffectORPC },
+  ] = await Promise.all([
+    import("@orpc/server"),
+    import("effect"),
+    import("../effect-builder"),
+  ]);
+
+  class CurrentUser extends Context.Tag("SideEffectImportCurrentUser")<
+    CurrentUser,
+    { readonly id: string }
+  >() {}
+
+  const runtime = ManagedRuntime.make(Layer.empty);
+  const runPromiseExit = vi.spyOn(runtime, "runPromiseExit");
+  const procedure = makeEffectORPC(runtime)
+    .$context<{ readonly user: { readonly id: string } }>()
+    .provide(CurrentUser, ({ context }) => Effect.succeed(context.user))
+    .use(function* ({ next }) {
+      return yield* next();
+    })
+    .use(({ next }) => next())
+    .use(function* ({ next }) {
+      const user = yield* CurrentUser;
+      return yield* next({ context: { userId: user.id } });
+    })
+    .effect(function* ({ context }) {
+      const user = yield* CurrentUser;
+      return `${context.userId}:${user.id}`;
+    });
+
+  return { call, procedure, runPromiseExit, runtime };
+}
+
+describe("node side-effect bridge", () => {
+  it("propagates FiberRefs across split Effect groups with only the side-effect import", async () => {
+    const { call, procedure, runPromiseExit, runtime } =
+      await makeSplitProcedure({ installNodeBridge: true });
+
+    try {
+      await expect(
+        call(procedure, undefined, { context: { user: { id: "u-side" } } }),
+      ).resolves.toBe("u-side:u-side");
+      expect(runPromiseExit).toHaveBeenCalledTimes(2);
+    } finally {
+      await runtime.dispose();
+    }
+  });
+
+  it("does not propagate FiberRefs across split Effect groups without the bridge", async () => {
+    const { call, procedure, runPromiseExit, runtime } =
+      await makeSplitProcedure({ installNodeBridge: false });
+
+    try {
+      await expect(
+        call(procedure, undefined, { context: { user: { id: "u-side" } } }),
+      ).rejects.toThrow();
+      expect(runPromiseExit).toHaveBeenCalledTimes(2);
+    } finally {
+      await runtime.dispose();
+    }
+  });
+});

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

@@ -42,9 +42,16 @@ const rootBuilder = makeEffectORPC(runtime)
   .$input(inputSchema)
   .errors(baseErrorMap);
 
-const withMiddlewares = rootBuilder.use(({ next }) =>
-  next({ context: { auth: true as boolean } }),
-);
+const authMiddleware: Middleware<
+  InitialContext,
+  { auth: boolean },
+  { input: string },
+  unknown,
+  any,
+  BaseMeta
+> = ({ next }) => next({ context: { auth: true as boolean } });
+
+const withMiddlewares = rootBuilder.use(authMiddleware);
 
 const procedureBuilder = withMiddlewares.meta(baseMeta);
 const withInput = procedureBuilder.input(inputSchema);

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

@@ -12,12 +12,21 @@ import {
   outputSchema,
 } from "./shared";
 
+const authMiddleware: Middleware<
+  InitialContext,
+  { auth: boolean },
+  { input: string },
+  unknown,
+  any,
+  BaseMeta
+> = ({ next }) => next({ context: { auth: true as boolean } });
+
 const procedure = makeEffectORPC(runtime)
   .$context<InitialContext>()
   .$meta({ mode: "dev" } as BaseMeta)
   .$input(inputSchema)
   .errors(baseErrorMap)
-  .use(({ next }) => next({ context: { auth: true as boolean } }))
+  .use(authMiddleware)
   .output(outputSchema)
   .effect(function* () {
     return { output: 456 };
@@ -61,13 +70,20 @@ describe("parity: @orpc/server procedure-decorated.test-d.ts", () => {
 
   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();
+      const middleware: Middleware<
+        CurrentContext,
+        { extra: boolean },
+        { input: string },
+        { output: number },
+        any,
+        BaseMeta
+      > = ({ next }, input, output) => {
+        expectTypeOf(input).toEqualTypeOf<{ input: string }>();
+        expectTypeOf(output).toBeFunction();
+        return next({ context: { extra: true } });
+      };
+
+      expectTypeOf(procedure.use(middleware)).toBeObject();
 
       procedure.use(
         // @ts-expect-error - invalid TInContext

package/src/tests/shared.ts

@@ -1,5 +1,5 @@
 import type { Meta, Schema } from "@orpc/contract";
-import { ContractProcedure, eventIterator } from "@orpc/contract";
+import { ContractProcedure } from "@orpc/contract";
 import * as z from "zod";
 
 export const inputSchema = z.object({
@@ -53,28 +53,4 @@ export const pong = new ContractProcedure<
   route: {},
 });
 
-export const router = {
-  ping,
-  pong,
-  nested: {
-    ping,
-    pong,
-  },
-};
-
-export const streamedOutputSchema = eventIterator(outputSchema);
-
-export const streamed = new ContractProcedure<
-  typeof inputSchema,
-  typeof streamedOutputSchema,
-  typeof baseErrorMap,
-  Meta
->({
-  errorMap: baseErrorMap,
-  meta: {},
-  route: {},
-  inputSchema,
-  outputSchema: streamedOutputSchema,
-});
-
 export type AssertExtends<_TActual extends TExpected, TExpected> = true;

package/src/types/effect-builder-surface.ts

@@ -20,13 +20,17 @@ import type {
   Router,
 } from "@orpc/server";
 import type { IntersectPick } from "@orpc/shared";
+import type { Context as EffectContext, Layer } from "effect";
 
 import type {
   EffectBuilderDef,
   EffectErrorMapToErrorMap,
+  EffectOrORPCMiddleware,
+  EffectOptionalProvider,
   EffectProcedureBuilderWithInput,
   EffectProcedureBuilderWithOutput,
   EffectProcedureHandler,
+  EffectProvider,
   EffectRouterBuilder,
   EnhancedEffectRouter,
 } from ".";
@@ -37,6 +41,9 @@ import type {
   MergedEffectErrorMap,
 } from "../tagged-error";
 
+type EffectTagIdentifier<T extends EffectContext.Tag<any, any>> =
+  T extends EffectContext.Tag<infer I, any> ? I : never;
+
 export interface EffectBuilderSurface<
   TInitialContext extends Context,
   TCurrentContext extends Context,
@@ -158,6 +165,28 @@ export interface EffectBuilderSurface<
    *
    * @see {@link https://orpc.dev/docs/middleware Middleware Docs}
    */
+  middleware<
+    UOutContext extends IntersectPick<TCurrentContext, UOutContext>,
+    TInput,
+    TOutput = any,
+  >(
+    middleware: EffectOrORPCMiddleware<
+      TInitialContext,
+      UOutContext,
+      TInput,
+      TOutput,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta
+    >,
+  ): DecoratedMiddleware<
+    TInitialContext,
+    UOutContext,
+    TInput,
+    TOutput,
+    any,
+    TMeta
+  >;
   middleware<
     UOutContext extends IntersectPick<TCurrentContext, UOutContext>,
     TInput,
@@ -212,6 +241,32 @@ export interface EffectBuilderSurface<
     TRequirementsProvided,
     TRuntimeError
   >;
+  /**
+   * Uses an Effect middleware or native oRPC middleware to modify the context, throw early, or modify the response.
+   */
+  use<
+    UOutContext extends IntersectPick<TCurrentContext, UOutContext>,
+    UInContext extends Context = TCurrentContext,
+  >(
+    middleware: EffectOrORPCMiddleware<
+      UInContext | TCurrentContext,
+      UOutContext,
+      InferSchemaOutput<TInputSchema>,
+      unknown,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta
+    >,
+  ): EffectBuilderSurface<
+    MergedInitialContext<TInitialContext, UInContext, TCurrentContext>,
+    MergedCurrentContext<TCurrentContext, UOutContext>,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >;
   /**
    * Uses a middleware to modify the context or improve the pipeline.
    *
@@ -241,6 +296,67 @@ export interface EffectBuilderSurface<
     TRequirementsProvided,
     TRuntimeError
   >;
+  /**
+   * Provides an Effect layer to downstream procedures.
+   */
+  provide<TLayerOut, TLayerError, TLayerIn extends TRequirementsProvided>(
+    layer: Layer.Layer<TLayerOut, TLayerError, TLayerIn>,
+  ): EffectBuilderSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided | TLayerOut,
+    TRuntimeError | TLayerError
+  >;
+  /**
+   * Provides a request-scoped Effect service to downstream procedures.
+   */
+  provide<TTag extends EffectContext.Tag<any, any>>(
+    tag: TTag,
+    provider: EffectProvider<
+      TCurrentContext,
+      InferSchemaOutput<TInputSchema>,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta,
+      TTag
+    >,
+  ): EffectBuilderSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided | EffectTagIdentifier<TTag>,
+    TRuntimeError
+  >;
+  /**
+   * Optionally provides a request-scoped Effect service to downstream procedures.
+   */
+  provideOptional<TTag extends EffectContext.Tag<any, any>>(
+    tag: TTag,
+    provider: EffectOptionalProvider<
+      TCurrentContext,
+      InferSchemaOutput<TInputSchema>,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta,
+      TTag
+    >,
+  ): EffectBuilderSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >;
   /**
    * Sets or updates the metadata.
    * The provided metadata is spared-merged with any existing metadata.
@@ -358,7 +474,7 @@ export interface EffectBuilderSurface<
   >;
   /**
    * Defines the handler of the procedure using an Effect.
-   * The Effect is executed using the ManagedRuntime provided during builder creation.
+   * The Effect is executed using the configured Effect runtime source.
    * The effect is automatically wrapped with `Effect.withSpan`.
    *
    * @see {@link https://orpc.dev/docs/procedure Procedure Docs}

package/src/types/effect-procedure-surface.ts

@@ -18,8 +18,15 @@ import type {
   ProcedureDef,
 } from "@orpc/server";
 import type { IntersectPick, MaybeOptionalOptions } from "@orpc/shared";
+import type { Context as EffectContext, Layer } from "effect";
 
-import type { EffectProcedureDef, EffectErrorMapToErrorMap } from ".";
+import type {
+  EffectErrorMapToErrorMap,
+  EffectOrORPCMiddleware,
+  EffectOptionalProvider,
+  EffectProcedureDef,
+  EffectProvider,
+} from ".";
 import type { EffectDecoratedProcedure } from "../effect-procedure";
 import type {
   EffectErrorConstructorMap,
@@ -27,6 +34,9 @@ import type {
   MergedEffectErrorMap,
 } from "../tagged-error";
 
+type EffectTagIdentifier<T extends EffectContext.Tag<any, any>> =
+  T extends EffectContext.Tag<infer I, any> ? I : never;
+
 export interface EffectDecoratedProcedureSurface<
   TInitialContext extends Context,
   TCurrentContext extends Context,
@@ -117,6 +127,93 @@ export interface EffectDecoratedProcedureSurface<
     TRequirementsProvided,
     TRuntimeError
   >;
+  /**
+   * Provides an Effect layer to downstream procedures.
+   */
+  provide<TLayerOut, TLayerError, TLayerIn extends TRequirementsProvided>(
+    layer: Layer.Layer<TLayerOut, TLayerError, TLayerIn>,
+  ): EffectDecoratedProcedure<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided | TLayerOut,
+    TRuntimeError | TLayerError
+  >;
+  /**
+   * Provides a request-scoped Effect service to downstream procedures.
+   */
+  provide<TTag extends EffectContext.Tag<any, any>>(
+    tag: TTag,
+    provider: EffectProvider<
+      TCurrentContext,
+      InferSchemaOutput<TInputSchema>,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta,
+      TTag
+    >,
+  ): EffectDecoratedProcedure<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided | EffectTagIdentifier<TTag>,
+    TRuntimeError
+  >;
+  /**
+   * Optionally provides a request-scoped Effect service to downstream procedures.
+   */
+  provideOptional<TTag extends EffectContext.Tag<any, any>>(
+    tag: TTag,
+    provider: EffectOptionalProvider<
+      TCurrentContext,
+      InferSchemaOutput<TInputSchema>,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta,
+      TTag
+    >,
+  ): EffectDecoratedProcedure<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >;
+  /**
+   * Uses an Effect middleware or native oRPC middleware to modify the context, throw early, or modify the response.
+   */
+  use<
+    UOutContext extends IntersectPick<TCurrentContext, UOutContext>,
+    UInContext extends Context = TCurrentContext,
+  >(
+    middleware: EffectOrORPCMiddleware<
+      UInContext | TCurrentContext,
+      UOutContext,
+      InferSchemaOutput<TInputSchema>,
+      InferSchemaInput<TOutputSchema>,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta
+    >,
+  ): EffectDecoratedProcedure<
+    MergedInitialContext<TInitialContext, UInContext, TCurrentContext>,
+    MergedCurrentContext<TCurrentContext, UOutContext>,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >;
   /**
    * Uses a middleware to modify the context or improve the pipeline.
    *