@effect/workflow 0.1.3 → 0.1.5

package/src/DurableDeferred.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import type { NonEmptyReadonlyArray } from "effect/Array"
 import type * as Brand from "effect/Brand"
 import type * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
@@ -10,7 +11,7 @@ import * as Exit from "effect/Exit"
 import { dual } from "effect/Function"
 import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
-import type * as Workflow from "./Workflow.js"
+import * as Workflow from "./Workflow.js"
 import type { WorkflowEngine, WorkflowInstance } from "./WorkflowEngine.js"
 
 /**
@@ -94,7 +95,7 @@ const await_: <Success extends Schema.Schema.Any, Error extends Schema.Schema.Al
 >(self: DurableDeferred<Success, Error>) {
   const engine = yield* EngineTag
   const instance = yield* InstanceTag
-  const oexit = yield* engine.deferredResult(self)
+  const oexit = yield* Workflow.wrapActivityResult(engine.deferredResult(self), Option.isNone)
   if (Option.isNone(oexit)) {
     instance.suspended = true
     return yield* Effect.interrupt
@@ -112,6 +113,106 @@ export {
   await_ as await
 }
 
+/**
+ * @since 1.0.0
+ * @category Combinators
+ */
+export const into: {
+  /**
+   * @since 1.0.0
+   * @category Combinators
+   */
+  <Success extends Schema.Schema.Any, Error extends Schema.Schema.All>(self: DurableDeferred<Success, Error>): <R>(effect: Effect.Effect<Success["Type"], Error["Type"], R>) => Effect.Effect<
+    Success["Type"],
+    Error["Type"],
+    R | WorkflowEngine | WorkflowInstance | Success["Context"] | Error["Context"]
+  >
+  /**
+   * @since 1.0.0
+   * @category Combinators
+   */
+  <Success extends Schema.Schema.Any, Error extends Schema.Schema.All, R>(
+    effect: Effect.Effect<Success["Type"], Error["Type"], R>,
+    self: DurableDeferred<Success, Error>
+  ): Effect.Effect<
+    Success["Type"],
+    Error["Type"],
+    R | WorkflowEngine | WorkflowInstance | Success["Context"] | Error["Context"]
+  >
+} = dual(2, <Success extends Schema.Schema.Any, Error extends Schema.Schema.All, R>(
+  effect: Effect.Effect<Success["Type"], Error["Type"], R>,
+  self: DurableDeferred<Success, Error>
+): Effect.Effect<
+  Success["Type"],
+  Error["Type"],
+  R | WorkflowEngine | WorkflowInstance | Success["Context"] | Error["Context"]
+> =>
+  Effect.contextWithEffect((context: Context.Context<WorkflowEngine | WorkflowInstance>) => {
+    const engine = Context.get(context, EngineTag)
+    const instance = Context.get(context, InstanceTag)
+    return Effect.onExit(
+      effect,
+      Effect.fnUntraced(function*(exit) {
+        if (instance.suspended) return
+        const encodedExit = yield* Effect.orDie(Schema.encode(self.exitSchema)(exit))
+        yield* engine.deferredDone({
+          workflowName: instance.workflow.name,
+          executionId: instance.executionId,
+          deferred: self,
+          exit: encodedExit as any
+        })
+      })
+    )
+  }))
+
+/**
+ * @since 1.0.0
+ * @category Racing
+ */
+export const raceAll = <
+  const Effects extends NonEmptyReadonlyArray<Effect.Effect<any, any, any>>,
+  SI,
+  SR,
+  EI,
+  ER
+>(options: {
+  name: string
+  success: Schema.Schema<
+    Effects[number] extends Effect.Effect<infer S, infer _E, infer _R> ? S : never,
+    SI,
+    SR
+  >
+  error: Schema.Schema<
+    Effects[number] extends Effect.Effect<infer _S, infer E, infer _R> ? E : never,
+    EI,
+    ER
+  >
+  effects: Effects
+}): Effect.Effect<
+  (Effects[number] extends Effect.Effect<infer _A, infer _E, infer _R> ? _A : never),
+  (Effects[number] extends Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
+  | (Effects[number] extends Effect.Effect<infer _A, infer _R, infer R> ? R : never)
+  | SR
+  | ER
+  | WorkflowEngine
+  | WorkflowInstance
+> => {
+  const deferred = make<any, any>(`raceAll/${options.name}`, {
+    success: options.success,
+    error: options.error
+  })
+  return Effect.gen(function*() {
+    const engine = yield* EngineTag
+    const oexit = yield* Workflow.wrapActivityResult(engine.deferredResult(deferred), Option.isNone)
+    if (Option.isSome(oexit)) {
+      return yield* (Effect.flatten(Effect.orDie(
+        Schema.decodeUnknown(deferred.exitSchema)(oexit.value)
+      )) as Effect.Effect<any, any, any>)
+    }
+    return yield* into(Effect.raceAll(options.effects), deferred)
+  })
+}
+
 /**
  * @since 1.0.0
  * @category Token

package/src/Workflow.ts

@@ -291,7 +291,6 @@ export const make = <
           if (result._tag === "Complete") {
             return yield* result.exit as Exit.Exit<Success["Type"], Error["Type"]>
           }
-          // @effect-diagnostics effect/floatingEffect:off
           sleep ??= (yield* Schedule.driver(suspendedRetrySchedule)).next(void 0).pipe(
             Effect.catchAll(() => Effect.dieMessage(`${options.name}.execute: suspendedRetrySchedule exhausted`))
           )
@@ -480,18 +479,47 @@ export const Result = <Success extends Schema.Schema.Any, Error extends Schema.S
  */
 export const intoResult = <A, E, R>(
   effect: Effect.Effect<A, E, R>
-): Effect.Effect<Result<A, E>, never, R | WorkflowInstance> =>
-  Effect.uninterruptibleMask((restore) =>
-    Effect.withFiberRuntime((fiber) =>
-      Effect.matchCause(restore(effect), {
-        onSuccess: (value) => new Complete({ exit: Exit.succeed(value) }),
-        onFailure(cause) {
-          const instance = Context.unsafeGet(fiber.currentContext, InstanceTag)
-          return instance.suspended ? new Suspended() : new Complete({ exit: Exit.failCause(cause) })
-        }
-      })
+): Effect.Effect<Result<A, E>, never, Exclude<R, Scope.Scope> | WorkflowInstance> =>
+  Effect.contextWithEffect((context: Context.Context<WorkflowInstance>) => {
+    const instance = Context.get(context, InstanceTag)
+    return Effect.uninterruptibleMask((restore) =>
+      restore(effect).pipe(
+        Effect.scoped,
+        Effect.matchCause({
+          onSuccess: (value) => new Complete({ exit: Exit.succeed(value) }),
+          onFailure: (cause) => instance.suspended ? new Suspended() : new Complete({ exit: Exit.failCause(cause) })
+        })
+      )
     )
-  )
+  })
+
+/**
+ * @since 1.0.0
+ * @category Result
+ */
+export const wrapActivityResult = <A, E, R>(
+  effect: Effect.Effect<A, E, R>,
+  isSuspend: (value: A) => boolean
+): Effect.Effect<A, E, R | WorkflowInstance> =>
+  Effect.contextWithEffect((context: Context.Context<WorkflowInstance>) => {
+    const instance = Context.get(context, InstanceTag)
+    const state = instance.activityState
+    if (instance.suspended) {
+      return state.count > 0 ?
+        state.latch.await.pipe(
+          Effect.andThen(Effect.yieldNow()),
+          Effect.andThen(Effect.interrupt)
+        ) :
+        Effect.interrupt
+    }
+    if (state.count === 0) state.latch.unsafeClose()
+    state.count++
+    return Effect.onExit(effect, (exit) => {
+      state.count--
+      const isSuspended = Exit.isSuccess(exit) && isSuspend(exit.value)
+      return state.count === 0 ? state.latch.open : isSuspended ? state.latch.await : Effect.void
+    })
+  })
 
 /**
  * Add compensation logic to an effect inside a Workflow. The compensation finalizer will be
@@ -541,14 +569,15 @@ export const withCompensation: {
   compensation: (value: A, cause: Cause.Cause<unknown>) => Effect.Effect<void, never, R2>
 ): Effect.Effect<A, E, R | R2 | WorkflowInstance | Scope.Scope> =>
   Effect.uninterruptibleMask((restore) =>
-    Effect.contextWithEffect((context: Context.Context<WorkflowInstance>) => {
-      const instance = Context.get(context, InstanceTag)
-      return Effect.tap(restore(effect), (value) =>
-        Effect.addFinalizer((exit) => {
-          if (Exit.isSuccess(exit) || instance.suspended) {
-            return Effect.void
-          }
-          return compensation(value, exit.cause)
-        }))
-    })
+    Effect.tap(
+      restore(effect),
+      (value) =>
+        Effect.contextWithEffect((context: Context.Context<WorkflowInstance>) =>
+          Effect.addFinalizer((exit) =>
+            Exit.isSuccess(exit) || Context.get(context, InstanceTag).suspended
+              ? Effect.void
+              : compensation(value, exit.cause)
+          )
+        )
+    )
   ))

package/src/WorkflowEngine.ts

@@ -2,7 +2,7 @@
  * @since 1.0.0
  */
 import * as Context from "effect/Context"
-import type * as Effect from "effect/Effect"
+import * as Effect from "effect/Effect"
 import type * as Option from "effect/Option"
 import type * as Schema from "effect/Schema"
 import type * as Activity from "./Activity.js"
@@ -48,14 +48,6 @@ export class WorkflowEngine extends Context.Tag("@effect/workflow/WorkflowEngine
       executionId: string
     ) => Effect.Effect<void>
 
-    /**
-     * Resume a suspended workflow.
-     */
-    readonly resume: (
-      workflowName: string,
-      executionId: string
-    ) => Effect.Effect<void>
-
     /**
      * Execute an activity from a workflow.
      */
@@ -118,5 +110,22 @@ export class WorkflowInstance extends Context.Tag("@effect/workflow/WorkflowEngi
      * Whether the workflow has requested to be suspended.
      */
     suspended: boolean
+
+    readonly activityState: {
+      count: number
+      readonly latch: Effect.Latch
+    }
   }
->() {}
+>() {
+  static initial(workflow: Workflow.Any, executionId: string): WorkflowInstance["Type"] {
+    return WorkflowInstance.of({
+      executionId,
+      workflow,
+      suspended: false,
+      activityState: {
+        count: 0,
+        latch: Effect.unsafeMakeLatch()
+      }
+    })
+  }
+}