add AbortSignal support to ManagedRuntime (#2293)

Author: tim-smart

.changeset/funny-rabbits-heal.md

@@ -0,0 +1,5 @@
+---
+"effect": patch
+---
+
+add AbortSignal support to ManagedRuntime

packages/effect/src/ManagedRuntime.ts

@@ -63,7 +63,9 @@ export interface ManagedRuntime<in R, out ER> extends Pipeable {
    * This method is effectful and should only be used at the edges of your
    * program.
    */
-  readonly runPromise: <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A>
+  readonly runPromise: <A, E>(effect: Effect.Effect<A, E, R>, options?: {
+    readonly signal?: AbortSignal | undefined
+  }) => Promise<A>
 
   /**
    * Runs the `Effect`, returning a JavaScript `Promise` that will be resolved
@@ -72,7 +74,9 @@ export interface ManagedRuntime<in R, out ER> extends Pipeable {
    * This method is effectful and should only be used at the edges of your
    * program.
    */
-  readonly runPromiseExit: <A, E>(effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, ER | E>>
+  readonly runPromiseExit: <A, E>(effect: Effect.Effect<A, E, R>, options?: {
+    readonly signal?: AbortSignal | undefined
+  }) => Promise<Exit.Exit<A, ER | E>>
 
   /**
    * Dispose of the resources associated with the runtime.

packages/effect/src/internal/managedRuntime.ts

@@ -88,10 +88,12 @@ export const make = <R, ER>(
         internalRuntime.unsafeRunSyncEffect(provide(self, effect)) :
         internalRuntime.unsafeRunSync(self.cachedRuntime)(effect)
     },
-    runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>): Promise<Exit<A, E | ER>> {
+    runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>, options?: {
+      readonly signal?: AbortSignal | undefined
+    }): Promise<Exit<A, E | ER>> {
       return self.cachedRuntime === undefined ?
-        internalRuntime.unsafeRunPromiseExitEffect(provide(self, effect)) :
-        internalRuntime.unsafeRunPromiseExit(self.cachedRuntime)(effect)
+        internalRuntime.unsafeRunPromiseExitEffect(provide(self, effect), options) :
+        internalRuntime.unsafeRunPromiseExit(self.cachedRuntime)(effect, options)
     },
     runCallback<A, E>(
       effect: Effect.Effect<A, E, R>,
@@ -101,10 +103,12 @@ export const make = <R, ER>(
         internalRuntime.unsafeRunCallback(internalRuntime.defaultRuntime)(provide(self, effect), options) :
         internalRuntime.unsafeRunCallback(self.cachedRuntime)(effect, options)
     },
-    runPromise<A, E>(effect: Effect.Effect<A, E, R>): Promise<A> {
+    runPromise<A, E>(effect: Effect.Effect<A, E, R>, options?: {
+      readonly signal?: AbortSignal | undefined
+    }): Promise<A> {
       return self.cachedRuntime === undefined ?
-        internalRuntime.unsafeRunPromiseEffect(provide(self, effect)) :
-        internalRuntime.unsafeRunPromise(self.cachedRuntime)(effect)
+        internalRuntime.unsafeRunPromiseEffect(provide(self, effect), options) :
+        internalRuntime.unsafeRunPromise(self.cachedRuntime)(effect, options)
     }
   }
   return self

packages/effect/src/internal/runtime.ts

@@ -258,9 +258,12 @@ export const unsafeRunSyncExit =
 
 /** @internal */
 export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
-<A, E>(effect: Effect.Effect<A, E, R>, options?: {
-  readonly signal?: AbortSignal
-}): Promise<A> =>
+<A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: {
+    readonly signal?: AbortSignal | undefined
+  } | undefined
+): Promise<A> =>
   unsafeRunPromiseExit(runtime)(effect, options).then((result) => {
     switch (result._tag) {
       case OpCodes.OP_SUCCESS: {
@@ -273,30 +276,32 @@ export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
   })
 
 /** @internal */
-export const unsafeRunPromiseExit =
-  <R>(runtime: Runtime.Runtime<R>) =>
-  <A, E>(effect: Effect.Effect<A, E, R>, options?: {
-    readonly signal?: AbortSignal
-  }): Promise<Exit.Exit<A, E>> =>
-    new Promise((resolve) => {
-      const op = fastPath(effect)
-      if (op) {
-        resolve(op)
-      }
-      const fiber = unsafeFork(runtime)(effect)
-      fiber.addObserver((exit) => {
-        resolve(exit)
-      })
-      if (options?.signal !== undefined) {
-        if (options.signal.aborted) {
+export const unsafeRunPromiseExit = <R>(runtime: Runtime.Runtime<R>) =>
+<A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: {
+    readonly signal?: AbortSignal | undefined
+  } | undefined
+): Promise<Exit.Exit<A, E>> =>
+  new Promise((resolve) => {
+    const op = fastPath(effect)
+    if (op) {
+      resolve(op)
+    }
+    const fiber = unsafeFork(runtime)(effect)
+    fiber.addObserver((exit) => {
+      resolve(exit)
+    })
+    if (options?.signal !== undefined) {
+      if (options.signal.aborted) {
+        fiber.unsafeInterruptAsFork(fiber.id())
+      } else {
+        options.signal.addEventListener("abort", () => {
           fiber.unsafeInterruptAsFork(fiber.id())
-        } else {
-          options.signal.addEventListener("abort", () => {
-            fiber.unsafeInterruptAsFork(fiber.id())
-          })
-        }
+        })
       }
-    })
+    }
+  })
 
 /** @internal */
 export class RuntimeImpl<in R> implements Runtime.Runtime<R> {