effect-orpc 0.2.2 → 0.4.0

package/src/effect-enhance-router.ts

@@ -16,10 +16,10 @@ import {
   type Context,
   type Lazyable,
 } from "@orpc/server";
-import type { ManagedRuntime } from "effect/ManagedRuntime";
 
 import { EffectProcedure } from "./effect-procedure";
 import { getEffectErrorMap, unwrapEffectUpstream } from "./extension/state";
+import type { EffectRuntimeRunner } from "./runtime-source";
 import { effectErrorMapToErrorMap, type EffectErrorMap } from "./tagged-error";
 import type { EffectErrorMapToErrorMap, EnhancedEffectRouter } from "./types";
 
@@ -31,7 +31,7 @@ interface EnhanceEffectRouterOptions<
   middlewares: readonly AnyMiddleware[];
   errorMap: TEffectErrorMap;
   dedupeLeadingMiddlewares: boolean;
-  runtime: ManagedRuntime<TRequirementsProvided, TRuntimeError>;
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>;
 }
 
 export function enhanceEffectRouter<
@@ -97,7 +97,7 @@ export function enhanceEffectRouter<
         source["~orpc"].inputValidationIndex + newMiddlewareAdded,
       outputValidationIndex:
         source["~orpc"].outputValidationIndex + newMiddlewareAdded,
-      runtime: options.runtime,
+      runner: options.runner,
     }) as any;
   }
 

package/src/effect-procedure.ts

@@ -9,14 +9,22 @@ import type {
   ProcedureDef,
 } from "@orpc/server";
 import {
+  Procedure,
   addMiddleware,
   createActionableClient,
   createProcedureClient,
   decorateMiddleware,
-  Procedure,
 } from "@orpc/server";
 import type { MaybeOptionalOptions } from "@orpc/shared";
+import { Layer } from "effect";
 
+import {
+  createEffectOptionalProviderMiddleware,
+  createEffectPipelineMiddleware,
+  createEffectProcedureHandler,
+  createEffectProviderMiddleware,
+  isEffectMiddleware,
+} from "./effect-runtime";
 import { composeSurfaceProxy } from "./extension/compose-surfaces";
 import {
   createNodeProxy,
@@ -30,7 +38,11 @@ import {
 } from "./extension/state";
 import type { EffectErrorMap, MergedEffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
-import type { EffectErrorMapToErrorMap, EffectProcedureDef } from "./types";
+import type {
+  EffectErrorMapToErrorMap,
+  EffectPipelineStep,
+  EffectProcedureDef,
+} from "./types";
 import type { EffectDecoratedProcedureSurface } from "./types/effect-procedure-surface";
 
 type AnyProcedureLike = Procedure<any, any, any, any, any, any>;
@@ -66,6 +78,8 @@ const procedureVirtualDescriptors = {
   callable: { enumerable: false },
   errors: { enumerable: false },
   meta: { enumerable: false },
+  provide: { enumerable: false },
+  provideOptional: { enumerable: false },
   route: { enumerable: false },
   use: { enumerable: false },
 } as const;
@@ -75,6 +89,8 @@ const decoratedProcedureVirtualKeys = [
   ...baseProcedureVirtualKeys,
   "errors",
   "meta",
+  "provide",
+  "provideOptional",
   "route",
   "use",
   "callable",
@@ -101,11 +117,69 @@ function getEffectProcedureDef(
 ): EffectProcedureDef<any, any, any, any, any, any, any, any> {
   return {
     ...context.upstream["~orpc"],
+    effectSteps: context.state.effectSteps,
+    effectHandler: context.state.effectHandler,
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime,
+    runner: context.state.runner,
+  };
+}
+
+function makeEffectProcedureHandler(
+  def: EffectProcedureDef<any, any, any, any, any, any, any, any>,
+) {
+  if (!def.effectHandler) {
+    return def.handler;
+  }
+
+  return createEffectProcedureHandler({
+    defaultCaptureStackTrace: def.effectHandler.defaultCaptureStackTrace,
+    effectErrorMap: def.effectErrorMap,
+    effectFn: def.effectHandler.effectFn,
+    effectSteps: def.effectSteps,
+    runner: def.runner,
+    spanConfig: def.effectHandler.spanConfig,
+  });
+}
+
+function withRebuiltEffectHandler(
+  def: EffectProcedureDef<any, any, any, any, any, any, any, any>,
+): EffectProcedureDef<any, any, any, any, any, any, any, any> {
+  return {
+    ...def,
+    handler: makeEffectProcedureHandler(def),
   };
 }
 
+function appendEffectStep(
+  def: EffectProcedureDef<any, any, any, any, any, any, any, any>,
+  step: EffectPipelineStep,
+): EffectProcedureDef<any, any, any, any, any, any, any, any> {
+  return withRebuiltEffectHandler({
+    ...def,
+    effectSteps: [...(def.effectSteps ?? []), step],
+  });
+}
+
+function flushEffectSteps(
+  def: EffectProcedureDef<any, any, any, any, any, any, any, any>,
+): EffectProcedureDef<any, any, any, any, any, any, any, any> {
+  if (!def.effectSteps?.length) {
+    return def;
+  }
+
+  const middleware = createEffectPipelineMiddleware({
+    effectErrorMap: def.effectErrorMap,
+    runner: def.runner,
+    steps: def.effectSteps,
+  });
+
+  return withRebuiltEffectHandler({
+    ...def,
+    effectSteps: undefined,
+    middlewares: addMiddleware(def.middlewares, middleware),
+  });
+}
+
 function createEffectProcedureProxy<
   T extends AnyEffectProcedure | AnyEffectDecoratedProcedure,
 >(
@@ -158,22 +232,113 @@ function createEffectProcedureProxy<
                 route: mergeRoute(getEffectProcedureDef(context).route, route),
               });
           });
+        case "provide":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (tagOrLayer: any, provider?: any) => {
+              const def = getEffectProcedureDef(context);
+
+              if (Layer.isLayer(tagOrLayer)) {
+                const step = {
+                  _tag: "provideLayer" as const,
+                  layer: tagOrLayer,
+                };
+
+                if (def.effectHandler) {
+                  return new EffectDecoratedProcedure(
+                    appendEffectStep(def, step),
+                  );
+                }
+
+                return new EffectDecoratedProcedure({
+                  ...def,
+                  middlewares: addMiddleware(
+                    def.middlewares,
+                    createEffectPipelineMiddleware({
+                      effectErrorMap: state.effectErrorMap,
+                      runner: state.runner,
+                      steps: [step],
+                    }),
+                  ),
+                });
+              }
+
+              if (def.effectHandler) {
+                return new EffectDecoratedProcedure(
+                  appendEffectStep(def, {
+                    _tag: "provide",
+                    provider,
+                    tag: tagOrLayer,
+                  }),
+                );
+              }
+
+              return new EffectDecoratedProcedure({
+                ...def,
+                middlewares: addMiddleware(
+                  def.middlewares,
+                  createEffectProviderMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    provider,
+                    runner: state.runner,
+                    tag: tagOrLayer,
+                  }),
+                ),
+              });
+            };
+          });
+        case "provideOptional":
+          return getOrCreateVirtualMethod(context, prop, () => {
+            return (tag: any, provider: any) => {
+              const def = getEffectProcedureDef(context);
+
+              if (def.effectHandler) {
+                return new EffectDecoratedProcedure(
+                  appendEffectStep(def, {
+                    _tag: "provideOptional",
+                    provider,
+                    tag,
+                  }),
+                );
+              }
+
+              return new EffectDecoratedProcedure({
+                ...def,
+                middlewares: addMiddleware(
+                  def.middlewares,
+                  createEffectOptionalProviderMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    provider,
+                    runner: state.runner,
+                    tag,
+                  }),
+                ),
+              });
+            };
+          });
         case "use":
           return getOrCreateVirtualMethod(context, prop, () => {
             return (
               middleware: AnyMiddleware,
               mapInput?: MapInputMiddleware<any, any>,
             ) => {
+              const def = getEffectProcedureDef(context);
+              if (!mapInput && isEffectMiddleware(middleware)) {
+                return new EffectDecoratedProcedure(
+                  appendEffectStep(def, {
+                    _tag: "middleware",
+                    middleware,
+                  }),
+                );
+              }
+
+              const flushedDef = flushEffectSteps(def);
               const mapped = mapInput
                 ? decorateMiddleware(middleware).mapInput(mapInput)
                 : middleware;
 
               return new EffectDecoratedProcedure({
-                ...getEffectProcedureDef(context),
-                middlewares: addMiddleware(
-                  getEffectProcedureDef(context).middlewares,
-                  mapped,
-                ),
+                ...flushedDef,
+                middlewares: addMiddleware(flushedDef.middlewares, mapped),
               });
             };
           });
@@ -302,10 +467,13 @@ export class EffectProcedure<
     >,
     procedure?: AnyProcedureLike,
   ) {
-    super(def);
-    attachEffectState(this, procedure ?? new Procedure(def), {
+    const { effectSteps, effectHandler, ...procedureDef } = def;
+    super(procedureDef);
+    attachEffectState(this, procedure ?? new Procedure(procedureDef), {
+      effectSteps,
+      effectHandler,
       effectErrorMap: def.effectErrorMap,
-      runtime: def.runtime,
+      runner: def.runner,
     });
 
     if (new.target === EffectProcedure) {
@@ -402,6 +570,32 @@ export class EffectDecoratedProcedure<
     TRequirementsProvided,
     TRuntimeError
   >["route"];
+  /**
+   * Provides a request-scoped Effect service to downstream procedures.
+   */
+  declare provide: EffectDecoratedProcedureSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >["provide"];
+  /**
+   * Optionally provides a request-scoped Effect service to downstream procedures.
+   */
+  declare provideOptional: EffectDecoratedProcedureSurface<
+    TInitialContext,
+    TCurrentContext,
+    TInputSchema,
+    TOutputSchema,
+    TEffectErrorMap,
+    TMeta,
+    TRequirementsProvided,
+    TRuntimeError
+  >["provideOptional"];
   /**
    * Uses a middleware to modify the context or improve the pipeline.
    *