effect-orpc 0.4.0 → 0.5.0

package/dist/index.js

@@ -39,7 +39,7 @@ import { Layer } from "effect";
 
 // src/effect-runtime.ts
 import { ORPCError as ORPCError2 } from "@orpc/contract";
-import { Cause as Cause2, Effect, Exit, Option } from "effect";
+import { Cause as Cause2, Effect, Exit, FiberRefs, Option } from "effect";
 
 // src/tagged-error.ts
 import {
@@ -175,6 +175,7 @@ function effectErrorMapToErrorMap(errorMap) {
 }
 
 // src/effect-runtime.ts
+var HybridContinuationSymbol = /* @__PURE__ */ Symbol("effect-orpc/HybridContinuation");
 function toORPCErrorFromCause(cause) {
   return Cause2.match(cause, {
     onDie(defect) {
@@ -230,17 +231,17 @@ function createEffectProcedureHandler(options) {
     };
     const spanName = spanConfig?.name ?? opts.path.join(".");
     const captureStackTrace = spanConfig?.captureStackTrace ?? defaultCaptureStackTrace;
-    const resolver = Effect.fnUntraced(effectFn);
-    const handlerEffect = resolver(effectOpts);
+    const handlerEffect = callEffectCallback(effectFn, effectOpts);
     const tracedEffect = Effect.withSpan(
       runEffectPipeline({
         baseOptions: effectOpts,
         effectErrorMap,
         final: (context) => Effect.map(
-          context === effectOpts.context ? handlerEffect : resolver({ ...effectOpts, context }),
+          context === effectOpts.context ? handlerEffect : callEffectCallback(effectFn, { ...effectOpts, context }),
           (output) => ({ output, context: {} })
         ),
         input: opts.input,
+        runner,
         steps: effectSteps
       }),
       spanName,
@@ -268,6 +269,7 @@ function createEffectPipelineMiddleware(options) {
         )
       ),
       input,
+      runner,
       steps
     });
     const exit = await runner.runPromiseExit(effect, {
@@ -277,12 +279,152 @@ function createEffectPipelineMiddleware(options) {
     return exit.value;
   };
 }
+function createEffectOrORPCMiddleware(options) {
+  const { runner, effectErrorMap, middleware } = options;
+  return async (opts, input, output) => {
+    const effectOptions = makeEffectMiddlewareOptions({
+      effectErrorMap,
+      final: opts.next,
+      options: opts,
+      output
+    });
+    return runEffectOrORPCMiddlewareCallback({
+      effectOptions,
+      input,
+      middleware,
+      nativeNext: opts.next,
+      runner,
+      signal: opts.signal
+    });
+  };
+}
+async function runEffectOrORPCMiddlewareCallback(options) {
+  const result = options.middleware(
+    options.effectOptions,
+    options.input,
+    options.effectOptions.output
+  );
+  const classified = classifyEffectOrORPCMiddlewareResult(result);
+  switch (classified._tag) {
+    case "nativeContinuation":
+      return classified.result;
+    case "nativeGuardOnly":
+      return options.nativeNext();
+    case "nativeResult":
+      return classified.result;
+    case "effect": {
+      const exit = await options.runner.runPromiseExit(
+        runEffectMiddlewareResult({
+          autoNext: () => options.effectOptions.next(),
+          effect: classified.effect,
+          nextInvoked: options.effectOptions.nextTracker.nextInvoked,
+          nextResult: options.effectOptions.nextTracker.nextResult
+        }),
+        { signal: options.signal }
+      );
+      if (Exit.isFailure(exit)) throw toORPCErrorFromCause(exit.cause);
+      return exit.value;
+    }
+  }
+}
+function classifyEffectOrORPCMiddlewareResult(result) {
+  if (isHybridContinuation(result)) {
+    return {
+      _tag: "nativeContinuation",
+      result
+    };
+  }
+  if (Effect.isEffect(result) || isGeneratorIterator(result)) {
+    return {
+      _tag: "effect",
+      effect: effectFromCallbackResult(result)
+    };
+  }
+  if (result === void 0) {
+    return { _tag: "nativeGuardOnly" };
+  }
+  return {
+    _tag: "nativeResult",
+    result
+  };
+}
+function runEffectMiddlewareResult(options) {
+  return Effect.flatMap(
+    options.effect,
+    (result) => resolveEffectMiddlewareContinuation({
+      autoNext: options.autoNext,
+      nextInvoked: options.nextInvoked,
+      nextResult: options.nextResult,
+      result
+    })
+  );
+}
+function makeEffectMiddlewareOptions(options) {
+  const nextTracker = createMiddlewareNextTracker();
+  const effectOptions = {
+    context: options.options.context,
+    path: options.options.path,
+    procedure: options.options.procedure,
+    signal: options.options.signal,
+    lastEventId: options.options.lastEventId,
+    errors: createEffectErrorConstructorMap(options.effectErrorMap),
+    next: nextTracker.wrapNext(
+      (...rest) => makeHybridMiddlewareContinuation({
+        final: options.final,
+        nextTracker,
+        rest
+      })
+    ),
+    nextTracker,
+    output: makeEffectMiddlewareOutput(options.output)
+  };
+  return effectOptions;
+}
+function makeHybridMiddlewareContinuation(options) {
+  const nextContext = options.rest[0]?.context ?? {};
+  const toEffectResult = (result) => ({
+    output: result.output,
+    context: nextContext
+  });
+  const effect = Effect.map(
+    withCurrentFiberContext(() => options.final(...options.rest)),
+    toEffectResult
+  );
+  return makeHybridContinuation(effect, {
+    onResult: options.nextTracker.setNextResult,
+    run: () => options.final(...options.rest),
+    toEffectResult
+  });
+}
+function makeHybridContinuation(effect, options) {
+  markHybridContinuation(effect);
+  attachPromiseLikeContinuation(
+    effect,
+    (onFulfilled, onRejected) => Promise.resolve(options.run()).then(options.toEffectResult).then((result) => {
+      options.onResult?.(result);
+      return result;
+    }).then(onFulfilled, onRejected)
+  );
+  return effect;
+}
+function markHybridContinuation(value) {
+  Object.defineProperty(value, HybridContinuationSymbol, {
+    configurable: true,
+    value: true
+  });
+}
+function attachPromiseLikeContinuation(value, then) {
+  Object.defineProperty(value, "then", {
+    configurable: true,
+    value: then
+  });
+}
 function createEffectProviderMiddleware(options) {
   const { runner, effectErrorMap, tag, provider } = options;
   return async (opts, input) => {
     const effectOpts = makeEffectOptions(opts, input, effectErrorMap);
     const effect = Effect.flatMap(
-      provider(effectOpts),
+      callEffectCallback(provider, effectOpts),
       (service) => Effect.provideService(
         withCurrentFiberContext(() => opts.next()),
         tag,
@@ -301,7 +443,7 @@ function createEffectOptionalProviderMiddleware(options) {
   return async (opts, input) => {
     const effectOpts = makeEffectOptions(opts, input, effectErrorMap);
     const effect = Effect.flatMap(
-      provider(effectOpts),
+      callEffectCallback(provider, effectOpts),
       (service) => Option.match(service, {
         onNone: () => withCurrentFiberContext(() => opts.next()),
         onSome: (value) => Effect.provideService(
@@ -318,9 +460,50 @@ function createEffectOptionalProviderMiddleware(options) {
     return exit.value;
   };
 }
-function isEffectMiddleware(value) {
+function callEffectCallback(callback, ...args) {
+  if (isGeneratorFunction(callback)) {
+    return Effect.fnUntraced(callback)(...args);
+  }
+  return Effect.suspend(() => {
+    try {
+      return effectFromCallbackResult(callback(...args));
+    } catch (error) {
+      return Effect.fail(error);
+    }
+  });
+}
+function effectFromCallbackResult(result) {
+  if (Effect.isEffect(result)) {
+    return result;
+  }
+  if (isGeneratorIterator(result)) {
+    return Effect.fnUntraced(function* () {
+      return yield* result;
+    })();
+  }
+  if (isPromiseLike(result)) {
+    return Effect.promise(() => result);
+  }
+  return Effect.succeed(result);
+}
+function isGeneratorIterator(value) {
+  return typeof value === "object" && value !== null && "next" in value && typeof value.next === "function" && "throw" in value && typeof value.throw === "function";
+}
+function isHybridContinuation(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && HybridContinuationSymbol in value;
+}
+function isPromiseLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && "then" in value && typeof value.then === "function";
+}
+function isGeneratorFunction(value) {
   return typeof value === "function" && value.constructor?.name === "GeneratorFunction";
 }
+function isEffectMiddleware(value) {
+  return isGeneratorFunction(value);
+}
+function isDecoratedMiddleware(value) {
+  return typeof value === "function" && "mapInput" in value && "concat" in value;
+}
 function makeEffectOptions(opts, input, effectErrorMap) {
   return {
     context: opts.context,
@@ -339,13 +522,13 @@ function runEffectPipeline(options) {
     const stepOptions = { ...options.baseOptions, context };
     if (step._tag === "provide") {
       return Effect.flatMap(
-        step.provider(stepOptions),
+        callEffectCallback(step.provider, stepOptions),
         (service) => Effect.provideService(run(index + 1, context), step.tag, service)
       );
     }
     if (step._tag === "provideOptional") {
       return Effect.flatMap(
-        step.provider(stepOptions),
+        callEffectCallback(step.provider, stepOptions),
         (service) => Option.match(service, {
           onNone: () => run(index + 1, context),
           onSome: (value) => Effect.provideService(run(index + 1, context), step.tag, value)
@@ -355,46 +538,57 @@ function runEffectPipeline(options) {
     if (step._tag === "provideLayer") {
       return Effect.provide(run(index + 1, context), step.layer);
     }
-    const nextTracker = createMiddlewareNextTracker();
-    const effectOptions = {
-      context,
-      path: stepOptions.path,
-      procedure: stepOptions.procedure,
-      signal: stepOptions.signal,
-      lastEventId: stepOptions.lastEventId,
-      errors: createEffectErrorConstructorMap(options.effectErrorMap),
-      next: nextTracker.wrapNext(
-        (...rest) => {
-          const nextContext = rest[0]?.context ?? {};
-          return Effect.map(
-            run(index + 1, { ...context, ...nextContext }),
-            (result) => ({
-              output: result.output,
-              context: nextContext
-            })
-          );
-        }
-      )
-    };
-    const effectOutput = makeEffectMiddlewareOutput((output) => ({ output, context: {} }));
-    const middlewareEffect = Effect.fnUntraced(step.middleware)(
-      effectOptions,
-      options.input,
-      effectOutput
-    );
-    return Effect.flatMap(
-      middlewareEffect,
-      (result) => resolveEffectMiddlewareContinuation({
-        autoNext: () => effectOptions.next(),
-        nextInvoked: nextTracker.nextInvoked,
-        nextResult: nextTracker.nextResult,
-        result
-      })
-    );
+    return Effect.flatMap(Effect.getFiberRefs, (fiberRefs) => {
+      const makeThenable = (effect) => makeThenableEffect(
+        effect,
+        options.runner,
+        fiberRefs,
+        stepOptions.signal
+      );
+      const nextTracker = createMiddlewareNextTracker(
+        makeThenable
+      );
+      const effectOptions = {
+        context,
+        path: stepOptions.path,
+        procedure: stepOptions.procedure,
+        signal: stepOptions.signal,
+        lastEventId: stepOptions.lastEventId,
+        errors: createEffectErrorConstructorMap(options.effectErrorMap),
+        next: nextTracker.wrapNext(
+          (...rest) => {
+            const nextContext = rest[0]?.context ?? {};
+            return Effect.map(
+              run(index + 1, { ...context, ...nextContext }),
+              (result) => ({
+                output: result.output,
+                context: nextContext
+              })
+            );
+          }
+        )
+      };
+      const effectOutput = makeEffectMiddlewareOutput((output) => ({ output, context: {} }), makeThenable);
+      const middlewareEffect = callEffectCallback(
+        step.middleware,
+        effectOptions,
+        options.input,
+        effectOutput
+      );
+      return Effect.flatMap(
+        middlewareEffect,
+        (result) => resolveEffectMiddlewareContinuation({
+          autoNext: () => effectOptions.next(),
+          nextInvoked: nextTracker.nextInvoked,
+          nextResult: nextTracker.nextResult,
+          result
+        })
+      );
+    });
   };
   return run(0, options.baseOptions.context);
 }
-function createMiddlewareNextTracker() {
+function createMiddlewareNextTracker(makeThenable) {
   let nextInvoked = false;
   let nextResult;
   return {
@@ -404,13 +598,26 @@ function createMiddlewareNextTracker() {
     get nextResult() {
       return nextResult;
     },
+    setNextResult(result) {
+      nextResult = result;
+    },
     wrapNext(nextFn) {
       return ((...args) => {
         nextInvoked = true;
-        return Effect.map(nextFn(...args), (result) => {
+        const inner = nextFn(...args);
+        const tracked = Effect.map(inner, (result) => {
           nextResult = result;
           return result;
         });
+        if (isHybridContinuation(inner)) {
+          markHybridContinuation(tracked);
+          attachPromiseLikeContinuation(
+            tracked,
+            inner.then.bind(inner)
+          );
+          return tracked;
+        }
+        return makeThenable ? makeThenable(tracked) : tracked;
       });
     }
   };
@@ -432,8 +639,43 @@ function resolveEffectMiddlewareContinuation(options) {
   }
   return autoNext();
 }
-function makeEffectMiddlewareOutput(output) {
-  return (value) => withCurrentFiberContext(() => output(value));
+function makeEffectMiddlewareOutput(output, makeThenable) {
+  return (value) => {
+    const effect = withCurrentFiberContext(() => output(value));
+    return makeThenable ? makeThenable(effect) : effect;
+  };
+}
+function makeThenableEffect(effect, runner, fiberRefs, signal) {
+  if ("then" in effect) {
+    return effect;
+  }
+  attachPromiseLikeContinuation(
+    effect,
+    (onFulfilled, onRejected) => runNestedEffect(effect, runner, fiberRefs, signal).then(
+      onFulfilled,
+      onRejected
+    )
+  );
+  return effect;
+}
+async function runNestedEffect(effect, runner, fiberRefs, signal) {
+  const exit = await runner.runPromiseExit(withFiberRefs(effect, fiberRefs), {
+    signal
+  });
+  if (Exit.isFailure(exit)) {
+    throw toORPCErrorFromCause(exit.cause);
+  }
+  return exit.value;
+}
+function withFiberRefs(effect, parentFiberRefs) {
+  return Effect.fiberIdWith(
+    (fiberId) => Effect.flatMap(
+      Effect.getFiberRefs,
+      (fiberRefs) => Effect.setFiberRefs(
+        FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
+      ).pipe(Effect.andThen(effect))
+    )
+  );
 }
 function withCurrentFiberContext(fn) {
   return Effect.flatMap(
@@ -818,15 +1060,33 @@ function createEffectProcedureProxy(target, decorated) {
             return (middleware, mapInput) => {
               const def = getEffectProcedureDef(context);
               if (!mapInput && isEffectMiddleware(middleware)) {
-                return new EffectDecoratedProcedure(
-                  appendEffectStep(def, {
-                    _tag: "middleware",
-                    middleware
-                  })
-                );
+                const step = {
+                  _tag: "middleware",
+                  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;
+              const mapped = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : isDecoratedMiddleware(middleware) ? middleware : createEffectOrORPCMiddleware({
+                effectErrorMap: state.effectErrorMap,
+                middleware,
+                runner: state.runner
+              });
               return new EffectDecoratedProcedure({
                 ...flushedDef,
                 middlewares: addMiddleware(flushedDef.middlewares, mapped)
@@ -938,7 +1198,7 @@ function enhanceEffectRouter(router, options) {
 }
 
 // src/runtime-source.ts
-import { Effect as Effect2, FiberRefs, ManagedRuntime } from "effect";
+import { Effect as Effect2, FiberRefs as FiberRefs2, ManagedRuntime } from "effect";
 function makeEffectRuntimeRunner(source) {
   if (source === void 0) {
     return {
@@ -970,7 +1230,7 @@ function withParentFiberRefs(effect) {
     (fiberId) => Effect2.flatMap(
       Effect2.getFiberRefs,
       (fiberRefs) => Effect2.setFiberRefs(
-        FiberRefs.joinAs(fiberRefs, fiberId, parentFiberRefs)
+        FiberRefs2.joinAs(fiberRefs, fiberId, parentFiberRefs)
       ).pipe(Effect2.andThen(effect))
     )
   ) : effect;
@@ -1116,25 +1376,22 @@ function createEffectBuilderProxy(target) {
         case "middleware":
           return getOrCreateVirtualMethod2(context, prop, () => {
             return (middleware) => {
-              if (isEffectMiddleware(middleware)) {
-                const effectMiddleware = createEffectPipelineMiddleware({
-                  effectErrorMap: state.effectErrorMap,
-                  runner: state.runner,
-                  steps: [
-                    ...state.effectSteps ?? [],
-                    { _tag: "middleware", 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", middleware }
+                ]
+              }) : createEffectOrORPCMiddleware({
+                effectErrorMap: state.effectErrorMap,
+                middleware,
+                runner: state.runner
+              });
               return Reflect.apply(
                 Reflect.get(source, "middleware", source),
                 source,
-                [middleware]
+                [effectMiddleware]
               );
             };
           });
@@ -1166,7 +1423,7 @@ function createEffectBuilderProxy(target) {
         case "use":
           return getOrCreateVirtualMethod2(context, prop, () => {
             return (middleware, ...rest) => {
-              if (isEffectMiddleware(middleware) && rest.length === 0) {
+              if (rest.length === 0 && isEffectMiddleware(middleware)) {
                 return wrapBuilderLike(
                   source,
                   appendEffectStep2(state, {
@@ -1179,7 +1436,14 @@ function createEffectBuilderProxy(target) {
               const nextBuilder = 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);
             };
@@ -1196,10 +1460,16 @@ function createEffectBuilderProxy(target) {
           });
         case "handler":
           return getOrCreateVirtualMethod2(context, prop, () => {
-            return (handler) => new EffectDecoratedProcedure({
-              ...effectDef,
-              handler
-            });
+            return (handler) => {
+              const flushed = flushEffectSteps2(source, state);
+              return new EffectDecoratedProcedure({
+                ...flushed.builder["~orpc"],
+                effectErrorMap: flushed.state.effectErrorMap,
+                runner: flushed.state.runner,
+                effectSteps: flushed.state.effectSteps,
+                handler
+              });
+            };
           });
         case "router":
           return getOrCreateVirtualMethod2(context, prop, () => {