effect-orpc 0.2.1 → 0.3.0

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.

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.
    *

package/src/types/index.ts

@@ -18,9 +18,19 @@ import type {
   ProcedureBuilderWithOutput,
   ProcedureDef,
   ProcedureHandlerOptions,
+  MiddlewareNextFnOptions,
+  MiddlewareOptions,
+  MiddlewareResult,
   RouterBuilder,
 } from "@orpc/server";
-import type { Effect, ManagedRuntime } from "effect";
+import type { MaybeOptionalOptions } from "@orpc/shared";
+import type {
+  Context as EffectContext,
+  Effect,
+  Layer,
+  ManagedRuntime,
+  Option,
+} from "effect";
 import type { YieldWrap } from "effect/Utils";
 
 import type {
@@ -68,6 +78,8 @@ export interface EffectBuilderDef<
    * Effect-extended error map that supports both traditional errors and tagged errors.
    */
   effectErrorMap: TEffectErrorMap;
+  effectSteps?: readonly EffectPipelineStep[];
+  effectHandler?: EffectProcedureHandlerConfig;
 }
 
 /**
@@ -92,6 +104,8 @@ export interface EffectProcedureDef<
 > {
   runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
+  effectSteps?: readonly EffectPipelineStep[];
+  effectHandler?: EffectProcedureHandlerConfig;
 }
 
 /**
@@ -139,6 +153,283 @@ export type EffectProcedureHandler<
   never
 >;
 
+export interface EffectProcedureHandlerConfig {
+  readonly effectFn: EffectProcedureHandler<any, any, any, any, any, any>;
+  readonly defaultCaptureStackTrace: () => string | undefined;
+  readonly spanConfig?: EffectSpanConfig;
+}
+
+type EffectTagService<T extends EffectContext.Tag<any, any>> =
+  T extends EffectContext.Tag<any, infer S> ? S : never;
+
+export type EffectProvider<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+  TTag extends EffectContext.Tag<any, any>,
+> = (
+  opt: ProcedureHandlerOptions<
+    TCurrentContext,
+    TInput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+) => Effect.Effect<
+  EffectTagService<TTag>,
+  EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+  TRequirementsProvided
+>;
+
+export type EffectOptionalProvider<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+  TTag extends EffectContext.Tag<any, any>,
+> = (
+  opt: ProcedureHandlerOptions<
+    TCurrentContext,
+    TInput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+) => Effect.Effect<
+  Option.Option<EffectTagService<TTag>>,
+  EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+  TRequirementsProvided
+>;
+
+interface EffectMiddlewareNext<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  <UOutContext extends Context = Record<never, never>>(
+    ...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<UOutContext>>
+  ): Effect.Effect<
+    EffectMiddlewareResult<UOutContext, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+export type EffectMiddlewareResult<TOutContext extends Context, TOutput> = {
+  readonly output: TOutput;
+  readonly context: TOutContext;
+};
+
+export interface EffectMiddlewareOutput<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  (
+    output: TOutput,
+  ): Effect.Effect<
+    EffectMiddlewareResult<Record<never, never>, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+/**
+ * Contextual typing bridge for `.use(...)` overloads.
+ *
+ * At runtime `next()` is either Effect-native or oRPC-native depending on
+ * whether the middleware is a generator function. At type-check time we need
+ * inline middleware to support both `return next()` and `yield* next()` without
+ * an explicit annotation. The return type is intentionally an intersection:
+ * assignable to `PromiseLike<A>` for native middleware, and yieldable as an
+ * `Effect<A, E, R>` for Effect middleware.
+ */
+type EffectAndPromiseLike<A, E, R> = Effect.Effect<A, E, R> & PromiseLike<A>;
+
+/** A `next` function that can be consumed by native oRPC or Effect middleware. */
+interface EffectOrORPCMiddlewareNext<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  <UOutContext extends Context = Record<never, never>>(
+    ...rest: MaybeOptionalOptions<MiddlewareNextFnOptions<UOutContext>>
+  ): EffectAndPromiseLike<
+    EffectMiddlewareResult<UOutContext, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+/** An `output` helper that can be consumed by native oRPC or Effect middleware. */
+interface EffectOrORPCMiddlewareOutput<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+> {
+  (
+    output: TOutput,
+  ): EffectAndPromiseLike<
+    EffectMiddlewareResult<Record<never, never>, TOutput>,
+    EffectErrorMapToUnion<TEffectErrorMap> | ORPCError<ORPCErrorCode, unknown>,
+    TRequirementsProvided
+  >;
+}
+
+/** Middleware options with the dual-shape `next` used for `.use(...)` inference. */
+type EffectOrORPCMiddlewareOptions<
+  TCurrentContext extends Context,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = Omit<
+  MiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+  "next"
+> & {
+  readonly next: EffectOrORPCMiddlewareNext<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >;
+};
+
+/**
+ * Public `.use(...)` middleware shape.
+ *
+ * Accepts native oRPC middleware returns (`result` / `PromiseLike<result>`) and
+ * Effect generator middleware returns. Runtime dispatch still uses
+ * `isEffectMiddleware(...)`; this type only makes the inline callback ergonomic.
+ */
+export type EffectOrORPCMiddleware<
+  TCurrentContext extends Context,
+  TOutContext extends Context,
+  TInput,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = (
+  opt: EffectOrORPCMiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    TMeta
+  >,
+  input: TInput,
+  output: EffectOrORPCMiddlewareOutput<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >,
+) =>
+  | MiddlewareResult<TOutContext, TOutput>
+  | PromiseLike<MiddlewareResult<TOutContext, TOutput>>
+  | Generator<
+      YieldWrap<
+        Effect.Effect<
+          unknown,
+          | EffectErrorMapToUnion<TEffectErrorMap>
+          | ORPCError<ORPCErrorCode, unknown>,
+          TRequirementsProvided
+        >
+      >,
+      EffectMiddlewareResult<TOutContext, TOutput> | void,
+      never
+    >;
+
+export type EffectMiddlewareOptions<
+  TCurrentContext extends Context,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = Omit<
+  MiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >,
+  "next"
+> & {
+  readonly next: EffectMiddlewareNext<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >;
+};
+
+export type EffectMiddleware<
+  TCurrentContext extends Context,
+  TOutContext extends Context,
+  TInput,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+> = (
+  opt: EffectMiddlewareOptions<
+    TCurrentContext,
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    TMeta
+  >,
+  input: TInput,
+  output: EffectMiddlewareOutput<
+    TOutput,
+    TEffectErrorMap,
+    TRequirementsProvided
+  >,
+) => Generator<
+  YieldWrap<
+    Effect.Effect<
+      unknown,
+      | EffectErrorMapToUnion<TEffectErrorMap>
+      | ORPCError<ORPCErrorCode, unknown>,
+      TRequirementsProvided
+    >
+  >,
+  EffectMiddlewareResult<TOutContext, TOutput> | void,
+  never
+>;
+
+type EffectProvideStep = {
+  readonly _tag: "provide";
+  readonly tag: EffectContext.Tag<any, any>;
+  readonly provider: EffectProvider<any, any, any, any, any, any>;
+};
+
+type EffectProvideOptionalStep = {
+  readonly _tag: "provideOptional";
+  readonly tag: EffectContext.Tag<any, any>;
+  readonly provider: EffectOptionalProvider<any, any, any, any, any, any>;
+};
+
+type EffectProvideLayerStep = {
+  readonly _tag: "provideLayer";
+  readonly layer: Layer.Layer<any, any, any>;
+};
+
+type EffectMiddlewareStep = {
+  readonly _tag: "middleware";
+  readonly middleware: EffectMiddleware<any, any, any, any, any, any, any>;
+};
+
+export type EffectPipelineStep =
+  | EffectProvideStep
+  | EffectProvideOptionalStep
+  | EffectProvideLayerStep
+  | EffectMiddlewareStep;
+
 export type EffectErrorMapToErrorMap<T extends EffectErrorMap> = {
   [K in keyof T as T[K] extends ErrorMapItem<AnySchema>
     ? K extends ORPCErrorCode