effect-orpc 0.2.2 → 0.4.0

package/src/effect-runtime.ts

@@ -1,21 +1,38 @@
-import { ORPCError } from "@orpc/contract";
+import { ORPCError, type Meta } from "@orpc/contract";
 import type {
   Context,
+  Middleware,
+  MiddlewareNextFnOptions,
+  MiddlewareOutputFn,
+  MiddlewareResult,
   ProcedureHandler,
   ProcedureHandlerOptions,
 } from "@orpc/server";
-import type { ManagedRuntime } from "effect";
-import { Cause, Effect, Exit, FiberRefs } from "effect";
+import type { Promisable } from "@orpc/shared";
+import { Cause, Effect, Exit, Option } from "effect";
 
-import { getCurrentFiberRefs } from "./fiber-context-bridge";
+import { runWithFiberRefs } from "./fiber-context-bridge";
+import type { EffectRuntimeRunner } from "./runtime-source";
 import type { EffectErrorConstructorMap, EffectErrorMap } from "./tagged-error";
 import {
   createEffectErrorConstructorMap,
   isORPCTaggedError,
 } from "./tagged-error";
-import type { EffectProcedureHandler, EffectSpanConfig } from "./types";
+import type {
+  EffectMiddleware,
+  EffectMiddlewareOptions,
+  EffectMiddlewareOutput,
+  EffectMiddlewareResult,
+  EffectOptionalProvider,
+  EffectPipelineStep,
+  EffectProcedureHandler,
+  EffectProvider,
+  EffectSpanConfig,
+} from "./types";
+
+type EffectTag = import("effect").Context.Tag<any, any>;
 
-export function toORPCErrorFromCause(
+function toORPCErrorFromCause(
   cause: Cause.Cause<unknown>,
 ): ORPCError<string, unknown> {
   return Cause.match(cause, {
@@ -59,9 +76,9 @@ export function createEffectProcedureHandler<
   TEffectErrorMap extends EffectErrorMap,
   TRequirementsProvided,
   TRuntimeError,
-  TMeta,
+  TMeta extends Meta,
 >(options: {
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   effectErrorMap: TEffectErrorMap;
   effectFn: EffectProcedureHandler<
     TCurrentContext,
@@ -71,6 +88,7 @@ export function createEffectProcedureHandler<
     TRequirementsProvided,
     any
   >;
+  effectSteps?: readonly EffectPipelineStep[];
   spanConfig?: EffectSpanConfig;
   defaultCaptureStackTrace: () => string | undefined;
 }): ProcedureHandler<
@@ -81,9 +99,10 @@ export function createEffectProcedureHandler<
   TMeta & Record<never, never>
 > {
   const {
-    runtime,
+    runner,
     effectErrorMap,
     effectFn,
+    effectSteps = [],
     spanConfig,
     defaultCaptureStackTrace,
   } = options;
@@ -108,20 +127,25 @@ export function createEffectProcedureHandler<
     const captureStackTrace =
       spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
     const resolver = Effect.fnUntraced(effectFn as any);
-    const tracedEffect = Effect.withSpan(resolver(effectOpts), spanName, {
-      captureStackTrace,
-    });
-    const parentFiberRefs = getCurrentFiberRefs();
-    const effectWithRefs = parentFiberRefs
-      ? Effect.fiberIdWith((fiberId) =>
-          Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>
-            Effect.setFiberRefs(
-              FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs),
-            ).pipe(Effect.andThen(tracedEffect)),
+    const handlerEffect = resolver(effectOpts);
+    const tracedEffect = Effect.withSpan(
+      runEffectPipeline({
+        baseOptions: effectOpts,
+        effectErrorMap,
+        final: (context) =>
+          Effect.map(
+            context === effectOpts.context
+              ? handlerEffect
+              : resolver({ ...effectOpts, context }),
+            (output) => ({ output, context: {} }),
           ),
-        )
-      : tracedEffect;
-    const exit = await runtime.runPromiseExit(effectWithRefs, {
+        input: opts.input,
+        steps: effectSteps,
+      }),
+      spanName,
+      { captureStackTrace },
+    );
+    const exit = await runner.runPromiseExit(tracedEffect, {
       signal: opts.signal,
     });
 
@@ -129,6 +153,404 @@ export function createEffectProcedureHandler<
       throw toORPCErrorFromCause(exit.cause);
     }
 
-    return exit.value as TOutput;
+    return exit.value.output as TOutput;
+  };
+}
+
+export function createEffectPipelineMiddleware<
+  TCurrentContext extends Context,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TRuntimeError,
+  TMeta extends Meta,
+>(options: {
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
+  effectErrorMap: TEffectErrorMap;
+  steps: readonly EffectPipelineStep[];
+}): Middleware<
+  TCurrentContext,
+  Record<never, never>,
+  unknown,
+  TOutput,
+  any,
+  TMeta
+> {
+  const { runner, effectErrorMap, steps } = options;
+
+  return async (opts, input) => {
+    const baseOptions = makeEffectOptions<
+      TCurrentContext,
+      unknown,
+      TEffectErrorMap,
+      TMeta
+    >(opts, input, effectErrorMap);
+    const effect = runEffectPipeline<
+      TCurrentContext,
+      unknown,
+      TOutput,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta
+    >({
+      baseOptions,
+      effectErrorMap,
+      final: (context) =>
+        withCurrentFiberContext(() =>
+          opts.next(
+            context === opts.context
+              ? undefined
+              : { context: context as Record<PropertyKey, unknown> },
+          ),
+        ) as any,
+      input,
+      steps,
+    });
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal,
+    });
+
+    if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+
+    return exit.value as MiddlewareResult<Record<never, never>, TOutput>;
+  };
+}
+
+export function createEffectProviderMiddleware<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TRuntimeError,
+  TMeta extends Meta,
+  TTag extends EffectTag,
+>(options: {
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
+  effectErrorMap: TEffectErrorMap;
+  tag: TTag;
+  provider: EffectProvider<
+    TCurrentContext,
+    TInput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    TMeta,
+    TTag
+  >;
+}): Middleware<TCurrentContext, Record<never, never>, TInput, any, any, TMeta> {
+  const { runner, effectErrorMap, tag, provider } = options;
+
+  return async (opts, input) => {
+    const effectOpts = makeEffectOptions<
+      TCurrentContext,
+      TInput,
+      TEffectErrorMap,
+      TMeta
+    >(opts, input, effectErrorMap);
+    const effect = Effect.flatMap(provider(effectOpts), (service) =>
+      Effect.provideService(
+        withCurrentFiberContext(() => opts.next()),
+        tag,
+        service,
+      ),
+    );
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal,
+    });
+
+    if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+
+    return exit.value;
   };
 }
+
+export function createEffectOptionalProviderMiddleware<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TRuntimeError,
+  TMeta extends Meta,
+  TTag extends EffectTag,
+>(options: {
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
+  effectErrorMap: TEffectErrorMap;
+  tag: TTag;
+  provider: EffectOptionalProvider<
+    TCurrentContext,
+    TInput,
+    TEffectErrorMap,
+    TRequirementsProvided,
+    TMeta,
+    TTag
+  >;
+}): Middleware<TCurrentContext, Record<never, never>, TInput, any, any, TMeta> {
+  const { runner, effectErrorMap, tag, provider } = options;
+
+  return async (opts, input) => {
+    const effectOpts = makeEffectOptions<
+      TCurrentContext,
+      TInput,
+      TEffectErrorMap,
+      TMeta
+    >(opts, input, effectErrorMap);
+    const effect = Effect.flatMap(provider(effectOpts), (service) =>
+      Option.match(service, {
+        onNone: () => withCurrentFiberContext(() => opts.next()),
+        onSome: (value) =>
+          Effect.provideService(
+            withCurrentFiberContext(() => opts.next()),
+            tag,
+            value,
+          ),
+      }),
+    );
+    const exit = await runner.runPromiseExit(effect, {
+      signal: opts.signal,
+    });
+
+    if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+
+    return exit.value;
+  };
+}
+
+// todo(utopy): make this check more comprehensive, maybe add a Symbol to the EffectMiddleware type
+export function isEffectMiddleware(
+  value: unknown,
+): value is EffectMiddleware<
+  Context,
+  Context,
+  unknown,
+  unknown,
+  EffectErrorMap,
+  unknown,
+  Meta
+> {
+  return (
+    typeof value === "function" &&
+    value.constructor?.name === "GeneratorFunction"
+  );
+}
+
+function makeEffectOptions<
+  TCurrentContext extends Context,
+  TInput,
+  TEffectErrorMap extends EffectErrorMap,
+  TMeta extends Meta,
+>(
+  opts: Parameters<
+    Middleware<TCurrentContext, any, TInput, any, any, TMeta>
+  >[0],
+  input: TInput,
+  effectErrorMap: TEffectErrorMap,
+): ProcedureHandlerOptions<
+  TCurrentContext,
+  TInput,
+  EffectErrorConstructorMap<TEffectErrorMap>,
+  TMeta & Record<never, never>
+> {
+  return {
+    context: opts.context,
+    input,
+    path: opts.path,
+    procedure: opts.procedure as any,
+    signal: opts.signal,
+    lastEventId: opts.lastEventId,
+    errors: createEffectErrorConstructorMap(effectErrorMap),
+  };
+}
+
+function runEffectPipeline<
+  TCurrentContext extends Context,
+  TInput,
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+  TMeta extends Meta,
+>(options: {
+  baseOptions: ProcedureHandlerOptions<
+    TCurrentContext,
+    TInput,
+    EffectErrorConstructorMap<TEffectErrorMap>,
+    TMeta
+  >;
+  effectErrorMap: TEffectErrorMap;
+  final: (
+    context: TCurrentContext,
+  ) => Effect.Effect<
+    EffectMiddlewareResult<Record<never, never>, TOutput>,
+    unknown,
+    TRequirementsProvided
+  >;
+  input: TInput;
+  steps: readonly EffectPipelineStep[];
+}): Effect.Effect<
+  EffectMiddlewareResult<Context, TOutput>,
+  unknown,
+  TRequirementsProvided
+> {
+  const run = (
+    index: number,
+    context: TCurrentContext,
+  ): Effect.Effect<
+    EffectMiddlewareResult<Context, TOutput>,
+    unknown,
+    TRequirementsProvided
+  > => {
+    const step = options.steps[index];
+    if (!step) return options.final(context);
+
+    const stepOptions = { ...options.baseOptions, context };
+
+    if (step._tag === "provide") {
+      return Effect.flatMap(step.provider(stepOptions as any), (service) =>
+        Effect.provideService(run(index + 1, context), step.tag, service),
+      );
+    }
+
+    if (step._tag === "provideOptional") {
+      return Effect.flatMap(step.provider(stepOptions as any), (service) =>
+        Option.match(service, {
+          onNone: () => run(index + 1, context),
+          onSome: (value) =>
+            Effect.provideService(run(index + 1, context), step.tag, value),
+        }),
+      );
+    }
+
+    if (step._tag === "provideLayer") {
+      return Effect.provide(run(index + 1, context), step.layer);
+    }
+
+    const nextTracker =
+      createMiddlewareNextTracker<EffectMiddlewareResult<Context, TOutput>>();
+    const effectOptions: EffectMiddlewareOptions<
+      TCurrentContext,
+      TOutput,
+      TEffectErrorMap,
+      TRequirementsProvided,
+      TMeta
+    > = {
+      context,
+      path: stepOptions.path,
+      procedure: stepOptions.procedure,
+      signal: stepOptions.signal,
+      lastEventId: stepOptions.lastEventId,
+      errors: createEffectErrorConstructorMap(options.effectErrorMap),
+      next: nextTracker.wrapNext(
+        (...rest: [MiddlewareNextFnOptions<Context>?]) => {
+          const nextContext = rest[0]?.context ?? {};
+          return Effect.map(
+            run(index + 1, { ...context, ...nextContext }),
+            (result) => ({
+              output: result.output,
+              context: nextContext,
+            }),
+          ) as Effect.Effect<EffectMiddlewareResult<Context, TOutput>>;
+        },
+      ),
+    };
+    const effectOutput = makeEffectMiddlewareOutput<
+      TOutput,
+      TEffectErrorMap,
+      TRequirementsProvided
+    >((output) => ({ output, context: {} }));
+    const middlewareEffect = Effect.fnUntraced(step.middleware)(
+      effectOptions,
+      options.input,
+      effectOutput,
+    ) as Effect.Effect<EffectMiddlewareResult<Context, TOutput> | void>;
+
+    return Effect.flatMap(middlewareEffect, (result) =>
+      resolveEffectMiddlewareContinuation({
+        autoNext: () => effectOptions.next(),
+        nextInvoked: nextTracker.nextInvoked,
+        nextResult: nextTracker.nextResult,
+        result,
+      }),
+    );
+  };
+
+  return run(0, options.baseOptions.context);
+}
+
+function createMiddlewareNextTracker<T>() {
+  let nextInvoked = false;
+  let nextResult: T | undefined;
+
+  return {
+    get nextInvoked() {
+      return nextInvoked;
+    },
+    get nextResult() {
+      return nextResult;
+    },
+    wrapNext<Fn extends (...args: any) => Effect.Effect<T, any, any>>(
+      nextFn: Fn,
+    ): Fn {
+      return ((...args: Parameters<Fn>) => {
+        nextInvoked = true;
+        return Effect.map(nextFn(...args), (result) => {
+          nextResult = result;
+          return result;
+        });
+      }) as Fn;
+    },
+  };
+}
+
+function resolveEffectMiddlewareContinuation<
+  TContext extends Context,
+  TOutput,
+  TRequirementsProvided,
+>(options: {
+  result: EffectMiddlewareResult<TContext, TOutput> | void;
+  nextInvoked: boolean;
+  nextResult: EffectMiddlewareResult<TContext, TOutput> | undefined;
+  autoNext: () => Effect.Effect<
+    EffectMiddlewareResult<TContext, TOutput>,
+    unknown,
+    TRequirementsProvided
+  >;
+}): Effect.Effect<
+  EffectMiddlewareResult<TContext, TOutput>,
+  unknown,
+  TRequirementsProvided
+> {
+  const { result, nextInvoked, nextResult, autoNext } = options;
+
+  if (result !== undefined) {
+    return Effect.succeed(result);
+  }
+
+  if (nextInvoked) {
+    if (nextResult === undefined) {
+      return Effect.die(
+        new Error(
+          "Effect middleware invoked next() but did not return its result",
+        ),
+      );
+    }
+    return Effect.succeed(nextResult);
+  }
+
+  return autoNext();
+}
+
+function makeEffectMiddlewareOutput<
+  TOutput,
+  TEffectErrorMap extends EffectErrorMap,
+  TRequirementsProvided,
+>(
+  output: MiddlewareOutputFn<TOutput>,
+): EffectMiddlewareOutput<TOutput, TEffectErrorMap, TRequirementsProvided> {
+  return (value: TOutput) => withCurrentFiberContext(() => output(value));
+}
+
+function withCurrentFiberContext<T>(fn: () => Promisable<T>): Effect.Effect<T> {
+  return Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>
+    Effect.promise(() =>
+      runWithFiberRefs(fiberRefs, () => Promise.resolve(fn())),
+    ),
+  );
+}

package/src/extension/create-node-proxy.ts

@@ -43,6 +43,12 @@ interface NodeProxyInternalConfig<
     result: unknown,
     receiver: unknown,
   ) => unknown;
+  wrapArgs?: (
+    context: NodeProxyContext<TTarget, TSource>,
+    prop: PropertyKey,
+    args: unknown[],
+    receiver: unknown,
+  ) => unknown[];
 }
 
 /**
@@ -93,6 +99,15 @@ export interface NodeProxyConfig<
     result: unknown,
     receiver: unknown,
   ) => unknown;
+  /**
+   * Rewrites arguments before forwarding upstream methods.
+   */
+  wrapArgs?: (
+    context: NodeProxyContext<TTarget, TSource>,
+    prop: PropertyKey,
+    args: unknown[],
+    receiver: unknown,
+  ) => unknown[];
 }
 
 function createNodeProxyContext<
@@ -124,7 +139,8 @@ function createBoundMethod<
   }
 
   const wrapped = (...args: unknown[]) => {
-    const result = Reflect.apply(value, context.upstream, args);
+    const nextArgs = config.wrapArgs?.(context, prop, args, receiver) ?? args;
+    const result = Reflect.apply(value, context.upstream, nextArgs);
     return config.wrapResult?.(context, prop, result, receiver) ?? result;
   };
 

package/src/extension/state.ts

@@ -1,7 +1,10 @@
-import type { ManagedRuntime } from "effect";
-
+import type { EffectRuntimeRunner } from "../runtime-source";
 import type { EffectErrorMap } from "../tagged-error";
-import type { EffectSpanConfig } from "../types";
+import type {
+  EffectPipelineStep,
+  EffectProcedureHandlerConfig,
+  EffectSpanConfig,
+} from "../types";
 
 export interface EffectExtensionState<
   TRequirementsProvided = any,
@@ -13,15 +16,20 @@ export interface EffectExtensionState<
    */
   effectErrorMap: EffectErrorMap;
   /**
-   * The Effect ManagedRuntime that provides services for Effect procedures.
-   * @see {@link ManagedRuntime.ManagedRuntime}
+   * Executes Effect values with the services configured for this builder.
    */
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
   /**
    * Configuration for Effect span tracing.
    * @see {@link EffectSpanConfig}
    */
   spanConfig?: EffectSpanConfig;
+  /**
+   * Pending Effect-native provider / middleware steps that have not been flushed
+   * into the oRPC middleware chain.
+   */
+  effectSteps?: readonly EffectPipelineStep[];
+  effectHandler?: EffectProcedureHandlerConfig;
 }
 
 export interface EffectInternals<TUpstream extends object = object> {
@@ -62,25 +70,13 @@ export function getEffectInternals<TUpstream extends object>(
   return target[effectInternalsSymbol];
 }
 
-export function getEffectUpstream<TUpstream extends object>(
+function getEffectUpstream<TUpstream extends object>(
   target: EffectProxyTarget<TUpstream>,
 ): TUpstream {
   return getEffectInternals(target).upstream;
 }
 
-export function getEffectState(
-  target: EffectProxyTarget,
-): EffectExtensionState {
-  return getEffectInternals(target).state;
-}
-
-export function getEffectMethodCache(
-  target: EffectProxyTarget,
-): Map<PropertyKey, unknown> {
-  return getEffectInternals(target).methodCache;
-}
-
-export function hasEffectState(value: unknown): value is EffectProxyTarget {
+function hasEffectState(value: unknown): value is EffectProxyTarget {
   return (
     typeof value === "object" &&
     value !== null &&

package/src/fiber-context-bridge.ts

@@ -2,6 +2,10 @@ import type { FiberRefs } from "effect";
 
 export interface FiberContextBridge {
   readonly getCurrentFiberRefs: () => FiberRefs.FiberRefs | undefined;
+  readonly runWithFiberRefs?: <T>(
+    fiberRefs: FiberRefs.FiberRefs,
+    fn: () => Promise<T>,
+  ) => Promise<T>;
 }
 
 let bridge: FiberContextBridge | undefined;
@@ -15,3 +19,12 @@ export function installFiberContextBridge(
 export function getCurrentFiberRefs(): FiberRefs.FiberRefs | undefined {
   return bridge?.getCurrentFiberRefs();
 }
+
+export function runWithFiberRefs<T>(
+  fiberRefs: FiberRefs.FiberRefs,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return bridge?.runWithFiberRefs
+    ? bridge.runWithFiberRefs(fiberRefs, fn)
+    : fn();
+}

package/src/index.ts

@@ -16,6 +16,7 @@ export type {
 export {
   addSpanStackTrace,
   EffectBuilder,
+  eos,
   makeEffectORPC,
 } from "./effect-builder";
 export { EffectDecoratedProcedure } from "./effect-procedure";

package/src/node.ts

@@ -12,12 +12,13 @@ const fiberRefsStorage = new AsyncLocalStorage<FiberRefs.FiberRefs>();
 
 const bridge: FiberContextBridge = {
   getCurrentFiberRefs: () => fiberRefsStorage.getStore(),
+  runWithFiberRefs: (fiberRefs, fn) => fiberRefsStorage.run(fiberRefs, fn),
 };
 
 installFiberContextBridge(bridge);
 
 export function withFiberContext<T>(fn: () => Promise<T>): Effect.Effect<T> {
   return Effect.flatMap(Effect.getFiberRefs, (fiberRefs) =>
-    Effect.promise(() => fiberRefsStorage.run(fiberRefs, fn)),
+    Effect.promise(() => bridge.runWithFiberRefs!(fiberRefs, fn)),
   );
 }