@typeonce/effect-machine-devtools 0.24.0 → 0.25.0

package/src/internal/browser/parallel-completion-example.ts

@@ -0,0 +1,199 @@
+import { Machine } from "@typeonce/effect-machine"
+import { Schema } from "effect"
+
+class Cart extends Schema.TaggedClass<Cart>("ParallelCart")("Cart", {
+  items: Schema.Number
+}) {}
+class Order extends Schema.TaggedClass<Order>("ParallelOrder")("Order", {
+  orderId: Schema.String,
+  total: Schema.Number
+}) {}
+class Payment extends Schema.TaggedClass<Payment>("ParallelPayment")("Payment", {
+  attempts: Schema.Number
+}) {}
+class AwaitingAuthorization extends Schema.TaggedClass<AwaitingAuthorization>("ParallelAwaitingAuthorization")(
+  "AwaitingAuthorization",
+  {}
+) {}
+class Authorized extends Schema.TaggedClass<Authorized>("ParallelAuthorized")("Authorized", {
+  authorizationId: Schema.String
+}) {}
+class Fulfillment extends Schema.TaggedClass<Fulfillment>("ParallelFulfillment")("Fulfillment", {
+  warehouse: Schema.String
+}) {}
+class WaitingForPayment extends Schema.TaggedClass<WaitingForPayment>("ParallelWaitingForPayment")(
+  "WaitingForPayment",
+  {}
+) {}
+class Packing extends Schema.TaggedClass<Packing>("ParallelPacking")("Packing", {
+  packageCount: Schema.Number
+}) {}
+class Shipped extends Schema.TaggedClass<Shipped>("ParallelShipped")("Shipped", {
+  trackingCode: Schema.String
+}) {}
+class OrderComplete extends Schema.TaggedClass<OrderComplete>("ParallelOrderComplete")("OrderComplete", {
+  orderId: Schema.String
+}) {}
+class OrderCancelled extends Schema.TaggedClass<OrderCancelled>("ParallelOrderCancelled")(
+  "OrderCancelled",
+  { reason: Schema.String }
+) {}
+
+class Checkout extends Schema.TaggedClass<Checkout>("ParallelCheckout")("Checkout", {
+  orderId: Schema.String,
+  total: Schema.Number
+}) {}
+class Authorize extends Schema.TaggedClass<Authorize>("ParallelAuthorize")("Authorize", {
+  authorizationId: Schema.String
+}) {}
+class DeclinePayment extends Schema.TaggedClass<DeclinePayment>("ParallelDeclinePayment")(
+  "DeclinePayment",
+  { reason: Schema.String }
+) {}
+class Pack extends Schema.TaggedClass<Pack>("ParallelPack")("Pack", { packages: Schema.Number }) {}
+class Ship extends Schema.TaggedClass<Ship>("ParallelShip")("Ship", { trackingCode: Schema.String }) {}
+class CompleteAll extends Schema.TaggedClass<CompleteAll>("ParallelCompleteAll")("CompleteAll", {
+  authorizationId: Schema.String,
+  trackingCode: Schema.String
+}) {}
+class CancelOrder extends Schema.TaggedClass<CancelOrder>("ParallelCancelOrder")("CancelOrder", {
+  reason: Schema.String
+}) {}
+class RetryOrder extends Schema.TaggedClass<RetryOrder>("ParallelRetryOrder")("RetryOrder", {}) {}
+class AutoShip extends Schema.TaggedClass<AutoShip>("ParallelAutoShip")("AutoShip", {}) {}
+
+const ParallelInternalEvents = Machine.internalEvents(AutoShip)
+const ParallelStates = Machine.states({
+  Cart,
+  Order: {
+    schema: Order,
+    type: "parallel",
+    states: {
+      payment: {
+        schema: Payment,
+        initial: "AwaitingAuthorization",
+        states: {
+          AwaitingAuthorization,
+          Authorized: { schema: Authorized, type: "final" }
+        }
+      },
+      fulfillment: {
+        schema: Fulfillment,
+        initial: "WaitingForPayment",
+        states: {
+          WaitingForPayment,
+          Packing,
+          Shipped: { schema: Shipped, type: "final" }
+        }
+      }
+    }
+  },
+  Complete: { schema: OrderComplete, type: "final", output: Schema.String },
+  Cancelled: OrderCancelled
+})
+
+export const parallelCompletionMachine = Machine.make({
+  id: "parallel-completion",
+  states: ParallelStates.states,
+  events: Machine.events(
+    Checkout,
+    Authorize,
+    DeclinePayment,
+    Pack,
+    Ship,
+    CompleteAll,
+    CancelOrder,
+    RetryOrder
+  ),
+  internalEvents: ParallelInternalEvents,
+  initial: (to) => to.Cart().resolve(({ target }) => target.decoded(new Cart({ items: 2 })))
+}).handle({
+  Cart: {
+    on: {
+      Checkout: (to) =>
+        to.full.Order.initial.resolve(({ event, target }) =>
+          target.decoded(new Order({ orderId: event.orderId, total: event.total }))
+        )
+    }
+  },
+  Order: {
+    initialize: ({ builder }) => builder.payment.from({ attempts: 0 }).fulfillment.from({ warehouse: "north" }),
+    on: {
+      CancelOrder: (to) =>
+        to.full.Cancelled().resolve(({ event, target }) => target.decoded(new OrderCancelled({ reason: event.reason })))
+    },
+    onDone: (to) =>
+      to.full.Complete().resolve(({ target }) => target.decoded(new OrderComplete({ orderId: "completed-order" }))),
+    states: {
+      payment: {
+        initialize: ({ builder }) => builder.from(),
+        states: {
+          AwaitingAuthorization: {
+            on: {
+              Authorize: (to) =>
+                to.local.Authorized().resolve(({ event, target }) =>
+                  target.decoded(new Authorized({ authorizationId: event.authorizationId }))
+                ),
+              CompleteAll: (to) =>
+                to.local.Authorized().resolve(({ event, target }) =>
+                  target.decoded(new Authorized({ authorizationId: event.authorizationId }))
+                ),
+              DeclinePayment: (to) =>
+                to.full.Cancelled().resolve(({ event, target }) =>
+                  target.decoded(new OrderCancelled({ reason: event.reason }))
+                )
+            }
+          }
+        }
+      },
+      fulfillment: {
+        initialize: ({ builder }) => builder.from(),
+        states: {
+          WaitingForPayment: {
+            on: {
+              Authorize: (to) =>
+                to.local.Packing().resolve(({ target }) => target.decoded(new Packing({ packageCount: 1 }))),
+              Pack: (to) =>
+                to.local.Packing().resolve(({ event, target }) =>
+                  target.decoded(new Packing({ packageCount: event.packages }))
+                ),
+              CompleteAll: (to) =>
+                to.local.Shipped().resolve(({ event, target }) =>
+                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                )
+            }
+          },
+          Packing: {
+            invoke: (from) =>
+              from.timer("packing-sla", "5 seconds").onDone((to) =>
+                to.none.resolve((_, enqueue) => {
+                  enqueue.raise(ParallelInternalEvents.AutoShip())
+                })
+              ),
+            on: {
+              AutoShip: (to) =>
+                to.local.Shipped().resolve(({ target }) => target.decoded(new Shipped({ trackingCode: "automatic" }))),
+              Ship: (to) =>
+                to.local.Shipped().resolve(({ event, target }) =>
+                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                ),
+              CompleteAll: (to) =>
+                to.local.Shipped().resolve(({ event, target }) =>
+                  target.decoded(new Shipped({ trackingCode: event.trackingCode }))
+                )
+            }
+          }
+        }
+      }
+    }
+  },
+  Complete: {
+    output: ({ state }) => state.orderId
+  },
+  Cancelled: {
+    on: {
+      RetryOrder: (to) =>
+        to.full.Order.initial.resolve(({ target }) => target.decoded(new Order({ orderId: "retry", total: 0 })))
+    }
+  }
+})

package/src/internal/browser/planner-example.ts

@@ -1,5 +1,6 @@
 import { Machine } from "@typeonce/effect-machine"
 import { Schema } from "effect"
+import * as Effect from "effect/Effect"
 
 class Idle extends Schema.TaggedClass<Idle>("PlannerIdle")("Idle", { owner: Schema.String }) {}
 class Working extends Schema.TaggedClass<Working>("PlannerWorking")("Working", {
@@ -128,6 +129,7 @@ export const plannerMachine = Machine.make({
     }
   },
   Working: {
+    invoke: (from) => from.effect("monitor-job", () => Effect.never),
     on: {
       AutoFinish: (to) =>
         to.full.Finished().resolve(({ state, target }) => target.decoded(new Finished({ job: state.job }))),

package/src/internal/browser/protocol-events-example.ts

@@ -0,0 +1,200 @@
+import { Machine } from "@typeonce/effect-machine"
+import { Schema } from "effect"
+
+class ChildProgress extends Schema.TaggedClass<ChildProgress>("ProtocolChildProgress")("ChildProgress", {
+  percent: Schema.Number
+}) {}
+class ChildFinished extends Schema.TaggedClass<ChildFinished>("ProtocolChildFinished")("ChildFinished", {
+  result: Schema.String
+}) {}
+class ChildProblem extends Schema.TaggedClass<ChildProblem>("ProtocolChildProblem")("ChildProblem", {
+  message: Schema.String
+}) {}
+
+const ParentEvents = Machine.events(ChildProgress, ChildFinished, ChildProblem)
+
+class ChildIdle extends Schema.TaggedClass<ChildIdle>("ProtocolChildIdle")("Idle", {}) {}
+class ChildWorking extends Schema.TaggedClass<ChildWorking>("ProtocolChildWorking")("Working", {
+  job: Schema.String,
+  progress: Schema.Number
+}) {}
+class ChildDone extends Schema.TaggedClass<ChildDone>("ProtocolChildDone")("Done", {
+  result: Schema.String
+}) {}
+class ChildCancelled extends Schema.TaggedClass<ChildCancelled>("ProtocolChildCancelled")("Cancelled", {
+  reason: Schema.String
+}) {}
+
+class BeginChildWork extends Schema.TaggedClass<BeginChildWork>("ProtocolBeginChildWork")("BeginChildWork", {
+  job: Schema.String
+}) {}
+class CancelChildWork extends Schema.TaggedClass<CancelChildWork>("ProtocolCancelChildWork")(
+  "CancelChildWork",
+  { reason: Schema.String }
+) {}
+class Heartbeat extends Schema.TaggedClass<Heartbeat>("ProtocolHeartbeat")("Heartbeat", {
+  percent: Schema.Number
+}) {}
+class CommitChildWork extends Schema.TaggedClass<CommitChildWork>("ProtocolCommitChildWork")(
+  "CommitChildWork",
+  {}
+) {}
+class ChildTrace extends Schema.TaggedClass<ChildTrace>("ProtocolChildTrace")("ChildTrace", {
+  message: Schema.String
+}) {}
+
+const ChildEvents = Machine.events(BeginChildWork, CancelChildWork)
+const ChildInternalEvents = Machine.internalEvents(Heartbeat, CommitChildWork)
+const ChildEmissions = Machine.emittedEvents(ChildTrace)
+const ChildStates = Machine.states({
+  Idle: ChildIdle,
+  Working: ChildWorking,
+  Done: { schema: ChildDone, type: "final", output: Schema.String },
+  Cancelled: { schema: ChildCancelled, type: "final", output: Schema.String }
+})
+
+export const requiredParentChildMachine = Machine.make({
+  id: "required-parent-child",
+  states: ChildStates.states,
+  events: ChildEvents,
+  internalEvents: ChildInternalEvents,
+  emittedEvents: ChildEmissions,
+  parent: Machine.parent(ParentEvents),
+  initial: (to) => to.Idle().resolve(({ target }) => target.decoded(new ChildIdle({})))
+}).handle({
+  Idle: {
+    on: {
+      BeginChildWork: (to) =>
+        to.full.Working().resolve(({ event, target }, enqueue) => {
+          enqueue.raise(ChildInternalEvents.Heartbeat({ percent: 25 }))
+          enqueue.emit(ChildEmissions.ChildTrace({ message: `started ${event.job}` }))
+          return target.decoded(new ChildWorking({ job: event.job, progress: 0 }))
+        })
+    }
+  },
+  Working: {
+    invoke: (from) =>
+      from.effect(
+        "report-progress-to-parent",
+        ({ parent, state }) => parent.send(ParentEvents.ChildProgress({ percent: state.progress }))
+      ).onDone((to) => to.none).onFailure((to) =>
+        to.full.Cancelled().resolve(({ error, target }) =>
+          target.decoded(new ChildCancelled({ reason: String(error) }))
+        )
+      ),
+    on: {
+      Heartbeat: (to) =>
+        to.full.Working().resolve(({ event, state, target }, enqueue) => {
+          enqueue.raise(ChildInternalEvents.CommitChildWork())
+          return target.decoded(new ChildWorking({ job: state.job, progress: event.percent }))
+        }),
+      CommitChildWork: (to) =>
+        to.full.Done().resolve(({ state, target }) =>
+          target.decoded(new ChildDone({ result: `${state.job}:complete` }))
+        ),
+      CancelChildWork: (to) =>
+        to.full.Cancelled().resolve(({ event, target }) => target.decoded(new ChildCancelled({ reason: event.reason })))
+    }
+  },
+  Done: {
+    output: ({ state }) => state.result
+  },
+  Cancelled: {
+    output: ({ state }) => state.reason
+  }
+})
+
+const ProtocolChild = Machine.child("protocol-child", requiredParentChildMachine)
+
+class ParentIdle extends Schema.TaggedClass<ParentIdle>("ProtocolParentIdle")("Idle", {}) {}
+class Supervising extends Schema.TaggedClass<Supervising>("ProtocolSupervising")("Supervising", {
+  latestProgress: Schema.Number
+}) {}
+class ParentComplete extends Schema.TaggedClass<ParentComplete>("ProtocolParentComplete")("Complete", {
+  result: Schema.String
+}) {}
+class ParentFailed extends Schema.TaggedClass<ParentFailed>("ProtocolParentFailed")("Failed", {
+  message: Schema.String
+}) {}
+class LaunchChild extends Schema.TaggedClass<LaunchChild>("ProtocolLaunchChild")("LaunchChild", {}) {}
+class ResetParent extends Schema.TaggedClass<ResetParent>("ProtocolResetParent")("ResetParent", {}) {}
+
+const ParentStates = Machine.states({
+  Idle: ParentIdle,
+  Supervising,
+  Complete: { schema: ParentComplete, type: "final", output: Schema.String },
+  Failed: ParentFailed
+})
+
+export const parentProtocolMachine = Machine.make({
+  id: "parent-child-protocol",
+  states: ParentStates.states,
+  events: Machine.events(LaunchChild, ResetParent, ParentEvents),
+  initial: (to) => to.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+}).handle({
+  Idle: {
+    on: {
+      LaunchChild: (to) =>
+        to.full.Supervising().resolve(({ target }) => target.decoded(new Supervising({ latestProgress: 0 })))
+    }
+  },
+  Supervising: {
+    invoke: (from) =>
+      from.child(ProtocolChild).onDone((to) =>
+        to.full.Complete().resolve(({ output, target }) => target.decoded(new ParentComplete({ result: output })))
+      ).onFailure((to) =>
+        to.full.Failed().resolve(({ error, target }) => target.decoded(new ParentFailed({ message: String(error) })))
+      ),
+    on: {
+      ChildProgress: (to) =>
+        to.full.Supervising().resolve(({ event, target }) =>
+          target.decoded(new Supervising({ latestProgress: event.percent }))
+        ),
+      ChildFinished: (to) =>
+        to.full.Complete().resolve(({ event, target }) => target.decoded(new ParentComplete({ result: event.result }))),
+      ChildProblem: (to) =>
+        to.full.Failed().resolve(({ event, target }) => target.decoded(new ParentFailed({ message: event.message }))),
+      ResetParent: (to) => to.full.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+    }
+  },
+  Complete: {
+    output: ({ state }) => state.result
+  },
+  Failed: {
+    on: {
+      ResetParent: (to) => to.full.Idle().resolve(({ target }) => target.decoded(new ParentIdle({})))
+    }
+  }
+})
+
+class Detached extends Schema.TaggedClass<Detached>("OptionalParentDetached")("Detached", {}) {}
+class Published extends Schema.TaggedClass<Published>("OptionalParentPublished")("Published", {
+  deliveredToParent: Schema.Boolean
+}) {}
+class PublishOutside extends Schema.TaggedClass<PublishOutside>("OptionalParentPublishOutside")(
+  "PublishOutside",
+  { result: Schema.String }
+) {}
+
+const OptionalParentStates = Machine.states({ Detached, Published })
+
+export const optionalParentMachine = Machine.make({
+  id: "optional-parent-protocol",
+  states: OptionalParentStates.states,
+  events: Machine.events(PublishOutside),
+  parent: Machine.optionalParent(ParentEvents),
+  initial: (to) => to.Detached().resolve(({ target }) => target.decoded(new Detached({})))
+}).handle({
+  Detached: {
+    on: {
+      PublishOutside: (to) =>
+        to.full.Published().resolve(({ event, parent, target }, enqueue) => {
+          if (parent !== undefined) {
+            enqueue.sendTo(parent, ParentEvents.ChildFinished({ result: event.result }))
+          }
+          return target.decoded(new Published({ deliveredToParent: parent !== undefined }))
+        })
+    }
+  },
+  Published: {}
+})