effect-orpc 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-orpc",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "keywords": [
     "effect",
     "orpc",

package/src/contract.ts

@@ -34,8 +34,11 @@ import { enhanceEffectRouter } from "./effect-enhance-router";
 import { EffectDecoratedProcedure } from "./effect-procedure";
 import { createEffectProcedureHandler } from "./effect-runtime";
 import { effectContractSymbol, getEffectContractErrorMap } from "./eoc";
-import type { EffectRuntimeSource } from "./runtime-source";
-import { toManagedRuntime } from "./runtime-source";
+import type {
+  EffectRuntimeRunner,
+  EffectRuntimeSource,
+} from "./runtime-source";
+import { makeEffectRuntimeRunner } from "./runtime-source";
 import type { EffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
 import type { EffectErrorMapToErrorMap, EffectProcedureHandler } from "./types";
@@ -316,13 +319,13 @@ const CONTRACT_HIDDEN_METHODS = new Set([
 ]);
 
 function makeEnhanceOptions<TRequirementsProvided, TRuntimeError>(
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>,
 ) {
   return {
     middlewares: [],
     errorMap: {},
     dedupeLeadingMiddlewares: true,
-    runtime,
+    runner,
   } as const;
 }
 
@@ -333,7 +336,7 @@ function wrapContractNode<
 >(
   contract: TContract,
   target: any,
-  runtime: ManagedRuntime.ManagedRuntime<TRequirementsProvided, TRuntimeError>,
+  runner: EffectRuntimeRunner<TRequirementsProvided, TRuntimeError>,
 ): EffectImplementerInternal<
   TContract,
   Context,
@@ -362,9 +365,9 @@ function wrapContractNode<
               ...currentTarget["~orpc"],
               errorMap: effectErrorMapToErrorMap(effectErrorMap),
               effectErrorMap,
-              runtime,
+              runner,
               handler: createEffectProcedureHandler({
-                runtime,
+                runner,
                 effectErrorMap,
                 effectFn,
                 defaultCaptureStackTrace: addSpanStackTrace(),
@@ -385,7 +388,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ),
-              runtime,
+              runner,
             );
 
           cache.set(prop, use);
@@ -405,7 +408,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ),
-              runtime,
+              runner,
             );
 
           cache.set(prop, wrappedMethod);
@@ -420,7 +423,7 @@ function wrapContractNode<
                 currentTarget,
                 args,
               ) as any,
-              makeEnhanceOptions(runtime),
+              makeEnhanceOptions(runner),
             );
 
           cache.set(prop, wrappedMethod);
@@ -431,7 +434,7 @@ function wrapContractNode<
           const child = wrapContractNode(
             (contract as Record<string, AnyContractRouter>)[prop]!,
             Reflect.get(currentTarget, prop, receiver),
-            runtime,
+            runner,
           );
 
           cache.set(prop, child);
@@ -512,7 +515,7 @@ export function implementEffect<
   return wrapContractNode(
     contract,
     implement(contract),
-    toManagedRuntime(source),
+    makeEffectRuntimeRunner(source),
   ) as EffectImplementer<
     TContract,
     Record<never, never>,

package/src/effect-builder.ts

@@ -12,8 +12,10 @@ import { Layer, ManagedRuntime } from "effect";
 import { enhanceEffectRouter } from "./effect-enhance-router";
 import { EffectDecoratedProcedure } from "./effect-procedure";
 import {
+  createEffectOrORPCMiddleware,
   createEffectPipelineMiddleware,
   createEffectProcedureHandler,
+  isDecoratedMiddleware,
   isEffectMiddleware,
 } from "./effect-runtime";
 import {
@@ -28,7 +30,7 @@ import {
   type EffectProxyTarget,
 } from "./extension/state";
 import type { EffectRuntimeSource } from "./runtime-source";
-import { toManagedRuntime } from "./runtime-source";
+import { makeEffectRuntimeRunner } from "./runtime-source";
 import type { EffectErrorMap, MergedEffectErrorMap } from "./tagged-error";
 import { effectErrorMapToErrorMap } from "./tagged-error";
 import type {
@@ -106,7 +108,7 @@ function getEffectBuilderDef(
   return {
     ...context.upstream["~orpc"],
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime,
+    runner: context.state.runner,
     spanConfig: context.state.spanConfig,
     effectSteps: context.state.effectSteps,
     effectHandler: context.state.effectHandler,
@@ -121,7 +123,7 @@ function wrapBuilderLike(
     {
       ...builder["~orpc"],
       effectErrorMap: state.effectErrorMap,
-      runtime: state.runtime,
+      runner: state.runner,
       spanConfig: state.spanConfig,
       effectSteps: state.effectSteps,
       effectHandler: state.effectHandler,
@@ -158,7 +160,7 @@ function flushEffectSteps(
 
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: state.effectErrorMap,
-    runtime: state.runtime,
+    runner: state.runner,
     steps: state.effectSteps,
   });
   return {
@@ -238,7 +240,7 @@ function createEffectBuilderProxy(
                     effectErrorMap: state.effectErrorMap,
                     effectFn,
                     effectSteps: state.effectSteps,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     spanConfig: state.spanConfig,
                   })(opts as any);
                 },
@@ -248,27 +250,25 @@ function createEffectBuilderProxy(
         case "middleware":
           return getOrCreateVirtualMethod(context, prop, () => {
             return (middleware: any) => {
-              if (isEffectMiddleware(middleware)) {
-                const effectMiddleware = createEffectPipelineMiddleware({
-                  effectErrorMap: state.effectErrorMap,
-                  runtime: state.runtime,
-                  steps: [
-                    ...(state.effectSteps ?? []),
-                    { _tag: "middleware" as const, middleware },
-                  ],
-                });
-
-                return Reflect.apply(
-                  Reflect.get(source, "middleware", source),
-                  source,
-                  [effectMiddleware],
-                );
-              }
+              const effectMiddleware = isEffectMiddleware(middleware)
+                ? createEffectPipelineMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    runner: state.runner,
+                    steps: [
+                      ...(state.effectSteps ?? []),
+                      { _tag: "middleware" as const, middleware },
+                    ],
+                  })
+                : createEffectOrORPCMiddleware({
+                    effectErrorMap: state.effectErrorMap,
+                    middleware,
+                    runner: state.runner,
+                  });
 
               return Reflect.apply(
                 Reflect.get(source, "middleware", source),
                 source,
-                [middleware],
+                [effectMiddleware],
               );
             };
           });
@@ -302,7 +302,7 @@ function createEffectBuilderProxy(
         case "use":
           return getOrCreateVirtualMethod(context, prop, () => {
             return (middleware: any, ...rest: unknown[]) => {
-              if (isEffectMiddleware(middleware) && rest.length === 0) {
+              if (rest.length === 0 && isEffectMiddleware(middleware)) {
                 return wrapBuilderLike(
                   source,
                   appendEffectStep(state, {
@@ -316,7 +316,16 @@ function createEffectBuilderProxy(
               const nextBuilder: AnyBuilderLike = Reflect.apply(
                 Reflect.get(flushed.builder, "use", flushed.builder),
                 flushed.builder,
-                [middleware, ...rest],
+                [
+                  rest.length === 0 && !isDecoratedMiddleware(middleware)
+                    ? createEffectOrORPCMiddleware({
+                        effectErrorMap: flushed.state.effectErrorMap,
+                        middleware,
+                        runner: flushed.state.runner,
+                      })
+                    : middleware,
+                  ...rest,
+                ],
               );
               return wrapBuilderLike(nextBuilder, flushed.state);
             };
@@ -347,11 +356,16 @@ function createEffectBuilderProxy(
                   any
                 >["handler"]
               >[0],
-            ) =>
-              new EffectDecoratedProcedure({
-                ...effectDef,
+            ) => {
+              const flushed = flushEffectSteps(source, state);
+              return new EffectDecoratedProcedure({
+                ...flushed.builder["~orpc"],
+                effectErrorMap: flushed.state.effectErrorMap,
+                runner: flushed.state.runner,
+                effectSteps: flushed.state.effectSteps,
                 handler,
               });
+            };
           });
         case "router":
           return getOrCreateVirtualMethod(context, prop, () => {
@@ -698,7 +712,7 @@ export class EffectBuilder<
    *
    * @example
    * ```ts
-   * const getUser = effectOs
+   * const getUser = effectProcedure
    *   .input(z.object({ id: z.string() }))
    *   .traced('users.getUser')
    *   .effect(function* ({ input }) {
@@ -734,7 +748,7 @@ export class EffectBuilder<
   >["handler"];
   /**
    * 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}
@@ -826,14 +840,13 @@ export class EffectBuilder<
     >,
     builder?: AnyBuilderLike,
   ) {
-    const { runtime, spanConfig, effectErrorMap, effectSteps, ...orpcDef } =
-      def;
+    const { runner, spanConfig, effectErrorMap, effectSteps, ...orpcDef } = def;
 
     attachEffectState(this, builder ?? new Builder(orpcDef), {
       effectSteps,
       effectHandler: def.effectHandler,
       effectErrorMap,
-      runtime,
+      runner,
       spanConfig,
     });
 
@@ -853,9 +866,9 @@ export class EffectBuilder<
  * import { makeEffectORPC } from '@orpc/effect'
  * import { Effect, Layer } from 'effect'
  *
- * const effectOs = makeEffectORPC(Layer.empty)
+ * const effectProcedure = makeEffectORPC(Layer.empty)
  *
- * const hello = effectOs.effect(() => Effect.succeed('Hello!'))
+ * const hello = effectProcedure.effect(() => Effect.succeed('Hello!'))
  * ```
  */
 export function makeEffectORPC(): EffectBuilder<
@@ -943,9 +956,9 @@ export function makeEffectORPC<TRequirementsProvided, TRuntimeError>(
  * const authedOs = os.use(authMiddleware)
  *
  * // Wrap it with Effect support
- * const effectOs = makeEffectORPC(UserServiceLive, authedOs)
+ * const effectProcedure = makeEffectORPC(UserServiceLive, authedOs)
  *
- * const getUser = effectOs
+ * const getUser = effectProcedure
  *   .input(z.object({ id: z.string() }))
  *   .effect(
  *     Effect.fn(function* ({ input }) {
@@ -1025,15 +1038,16 @@ export function makeEffectORPC(
     ? source
     : (builder ?? emptyBuilder());
   const effectErrorMap = getEffectErrorMap(resolvedBuilder);
-  const runtime = toManagedRuntime(
-    sourceIsBuilder || source === undefined ? Layer.empty : source,
-  );
+  const runner =
+    sourceIsBuilder || source === undefined
+      ? makeEffectRuntimeRunner()
+      : makeEffectRuntimeRunner(source);
   return new EffectBuilder(
     {
       ...resolvedBuilder["~orpc"],
       effectErrorMap: effectErrorMap,
       errorMap: effectErrorMapToErrorMap(effectErrorMap),
-      runtime,
+      runner,
     },
     unwrapEffectUpstream(resolvedBuilder),
   );
@@ -1051,3 +1065,12 @@ function emptyBuilder(): AnyBuilderLike {
     route: {},
   });
 }
+
+/**
+ * Runtime-less Effect oRPC builder, analogous to oRPC's `os` export.
+ *
+ * Provide application services with `.provide(layer)` or use
+ * `makeEffectORPC(runtime)` when you need explicit ManagedRuntime lifecycle
+ * control.
+ */
+export const eos = makeEffectORPC();

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

@@ -20,9 +20,11 @@ import { Layer } from "effect";
 
 import {
   createEffectOptionalProviderMiddleware,
+  createEffectOrORPCMiddleware,
   createEffectPipelineMiddleware,
   createEffectProcedureHandler,
   createEffectProviderMiddleware,
+  isDecoratedMiddleware,
   isEffectMiddleware,
 } from "./effect-runtime";
 import { composeSurfaceProxy } from "./extension/compose-surfaces";
@@ -120,7 +122,7 @@ function getEffectProcedureDef(
     effectSteps: context.state.effectSteps,
     effectHandler: context.state.effectHandler,
     effectErrorMap: context.state.effectErrorMap,
-    runtime: context.state.runtime,
+    runner: context.state.runner,
   };
 }
 
@@ -136,7 +138,7 @@ function makeEffectProcedureHandler(
     effectErrorMap: def.effectErrorMap,
     effectFn: def.effectHandler.effectFn,
     effectSteps: def.effectSteps,
-    runtime: def.runtime,
+    runner: def.runner,
     spanConfig: def.effectHandler.spanConfig,
   });
 }
@@ -169,7 +171,7 @@ function flushEffectSteps(
 
   const middleware = createEffectPipelineMiddleware({
     effectErrorMap: def.effectErrorMap,
-    runtime: def.runtime,
+    runner: def.runner,
     steps: def.effectSteps,
   });
 
@@ -255,7 +257,7 @@ function createEffectProcedureProxy<
                     def.middlewares,
                     createEffectPipelineMiddleware({
                       effectErrorMap: state.effectErrorMap,
-                      runtime: state.runtime,
+                      runner: state.runner,
                       steps: [step],
                     }),
                   ),
@@ -279,7 +281,7 @@ function createEffectProcedureProxy<
                   createEffectProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag: tagOrLayer,
                   }),
                 ),
@@ -308,7 +310,7 @@ function createEffectProcedureProxy<
                   createEffectOptionalProviderMiddleware({
                     effectErrorMap: state.effectErrorMap,
                     provider,
-                    runtime: state.runtime,
+                    runner: state.runner,
                     tag,
                   }),
                 ),
@@ -323,18 +325,40 @@ function createEffectProcedureProxy<
             ) => {
               const def = getEffectProcedureDef(context);
               if (!mapInput && isEffectMiddleware(middleware)) {
-                return new EffectDecoratedProcedure(
-                  appendEffectStep(def, {
-                    _tag: "middleware",
-                    middleware,
-                  }),
-                );
+                const step: EffectPipelineStep = {
+                  _tag: "middleware" as const,
+                  middleware,
+                };
+
+                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],
+                    }),
+                  ),
+                });
               }
 
               const flushedDef = flushEffectSteps(def);
               const mapped = mapInput
                 ? decorateMiddleware(middleware).mapInput(mapInput)
-                : middleware;
+                : isDecoratedMiddleware(middleware)
+                  ? middleware
+                  : createEffectOrORPCMiddleware({
+                      effectErrorMap: state.effectErrorMap,
+                      middleware: middleware as any,
+                      runner: state.runner,
+                    });
 
               return new EffectDecoratedProcedure({
                 ...flushedDef,
@@ -473,7 +497,7 @@ export class EffectProcedure<
       effectSteps,
       effectHandler,
       effectErrorMap: def.effectErrorMap,
-      runtime: def.runtime,
+      runner: def.runner,
     });
 
     if (new.target === EffectProcedure) {