add support for AbortSignal's to runPromise

.changeset/five-games-sneeze.md

@@ -0,0 +1,18 @@
+---
+"effect": patch
+---
+
+add support for AbortSignal's to runPromise
+
+If the signal is aborted, the effect execution will be interrupted.
+
+```ts
+import { Effect } from "effect";
+
+const controller = new AbortController();
+
+Effect.runPromise(Effect.never, { signal: controller.signal });
+
+// abort after 1 second
+setTimeout(() => controller.abort(), 1000);
+```

packages/effect/src/Effect.ts

@@ -4672,7 +4672,10 @@ export const runCallback: <A, E>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <A, E>(effect: Effect<A, E>) => Promise<A> = _runtime.unsafeRunPromiseEffect
+export const runPromise: <A, E>(
+  effect: Effect<A, E, never>,
+  options?: { readonly signal?: AbortSignal } | undefined
+) => Promise<A> = _runtime.unsafeRunPromiseEffect
 
 /**
  * Runs an `Effect` workflow, returning a `Promise` which resolves with the
@@ -4681,8 +4684,10 @@ export const runPromise: <A, E>(effect: Effect<A, E>) => Promise<A> = _runtime.u
  * @since 2.0.0
  * @category execution
  */
-export const runPromiseExit: <A, E>(effect: Effect<A, E>) => Promise<Exit.Exit<A, E>> =
-  _runtime.unsafeRunPromiseExitEffect
+export const runPromiseExit: <A, E>(
+  effect: Effect<A, E, never>,
+  options?: { readonly signal?: AbortSignal } | undefined
+) => Promise<Exit.Exit<A, E>> = _runtime.unsafeRunPromiseExitEffect
 
 /**
  * @since 2.0.0

packages/effect/src/Runtime.ts

@@ -134,7 +134,9 @@ export const runCallback: <R>(
  * @since 2.0.0
  * @category execution
  */
-export const runPromise: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A> =
+export const runPromise: <R>(
+  runtime: Runtime<R>
+) => <A, E>(effect: Effect.Effect<A, E, R>, options?: { readonly signal?: AbortSignal } | undefined) => Promise<A> =
   internal.unsafeRunPromise
 
 /**
@@ -149,7 +151,10 @@ export const runPromise: <R>(runtime: Runtime<R>) => <A, E>(effect: Effect.Effec
  */
 export const runPromiseExit: <R>(
   runtime: Runtime<R>
-) => <A, E>(effect: Effect.Effect<A, E, R>) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
+) => <A, E>(
+  effect: Effect.Effect<A, E, R>,
+  options?: { readonly signal?: AbortSignal } | undefined
+) => Promise<Exit.Exit<A, E>> = internal.unsafeRunPromiseExit
 
 /**
  * @since 2.0.0

packages/effect/src/internal/runtime.ts

@@ -257,30 +257,39 @@ export const unsafeRunSyncExit =
   }
 
 /** @internal */
-export const unsafeRunPromise =
-  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Promise<A> =>
-    unsafeRunPromiseExit(runtime)(effect).then((result) => {
-      switch (result._tag) {
-        case OpCodes.OP_SUCCESS: {
-          return result.i0
-        }
-        case OpCodes.OP_FAILURE: {
-          throw fiberFailure(result.i0)
-        }
+export const unsafeRunPromise = <R>(runtime: Runtime.Runtime<R>) =>
+<A, E>(effect: Effect.Effect<A, E, R>, options?: {
+  readonly signal?: AbortSignal
+}): Promise<A> =>
+  unsafeRunPromiseExit(runtime)(effect, options).then((result) => {
+    switch (result._tag) {
+      case OpCodes.OP_SUCCESS: {
+        return result.i0
       }
-    })
+      case OpCodes.OP_FAILURE: {
+        throw fiberFailure(result.i0)
+      }
+    }
+  })
 
 /** @internal */
 export const unsafeRunPromiseExit =
-  <R>(runtime: Runtime.Runtime<R>) => <A, E>(effect: Effect.Effect<A, E, R>): Promise<Exit.Exit<A, E>> =>
+  <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)
       }
-      unsafeFork(runtime)(effect).addObserver((exit) => {
+      const fiber = unsafeFork(runtime)(effect)
+      fiber.addObserver((exit) => {
         resolve(exit)
       })
+      options?.signal?.addEventListener("abort", () => {
+        fiber.unsafeInterruptAsFork(fiber.id())
+      })
     })
 
 /** @internal */