@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/tests/DomainGraphTest.res.mjs

@@ -0,0 +1,413 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DomainGraph$ReventlessGwt from "../src/DomainGraph.res.mjs";
+
+function command(name, mutationField, apiExposedOpt) {
+  let apiExposed = apiExposedOpt !== undefined ? Primitive_option.valFromOption(apiExposedOpt) : undefined;
+  return {
+    name: name,
+    schema: "",
+    level: "Instance",
+    aggregateIdField: undefined,
+    mutationField: mutationField,
+    references: [],
+    allowedStates: undefined,
+    apiExposed: apiExposed
+  };
+}
+
+function evt(name) {
+  return {
+    name: name,
+    schema: "",
+    references: []
+  };
+}
+
+function writable(name, commandsOpt, producesOpt, consumesOpt, linkedViewsOpt, eventsOpt) {
+  let commands = commandsOpt !== undefined ? commandsOpt : [];
+  let produces = producesOpt !== undefined ? producesOpt : [];
+  let consumes = consumesOpt !== undefined ? consumesOpt : [];
+  let linkedViews = linkedViewsOpt !== undefined ? linkedViewsOpt : [];
+  let events = eventsOpt !== undefined ? eventsOpt : [];
+  return {
+    name: name,
+    commands: commands,
+    producedEventTypes: produces,
+    consumedEventTypes: consumes,
+    linkedViews: linkedViews,
+    consistencyRead: undefined,
+    events: events
+  };
+}
+
+function queryable(name, consumesOpt, visibilityOpt) {
+  let consumes = consumesOpt !== undefined ? consumesOpt : [];
+  let visibility = visibilityOpt !== undefined ? Primitive_option.valFromOption(visibilityOpt) : undefined;
+  return {
+    name: name,
+    queryField: "",
+    schema: "",
+    consumedEventTypes: consumes,
+    linkedWriteSide: [],
+    labelField: "id",
+    searchableFields: [],
+    statusField: undefined,
+    visibility: visibility
+  };
+}
+
+function automation(name, consumesOpt, producesOpt, targetOpt) {
+  let consumes = consumesOpt !== undefined ? consumesOpt : [];
+  let produces = producesOpt !== undefined ? producesOpt : [];
+  let target = targetOpt !== undefined ? targetOpt : "";
+  return {
+    name: name,
+    consumedEventTypes: consumes,
+    producedCommandTypes: produces,
+    targetName: target
+  };
+}
+
+function inbound(name, producesOpt, targetOpt) {
+  let produces = producesOpt !== undefined ? producesOpt : [];
+  let target = targetOpt !== undefined ? targetOpt : "";
+  return {
+    name: name,
+    commandTypes: produces,
+    targetName: target
+  };
+}
+
+function outbound(name, consumesOpt, producesOpt, targetOpt) {
+  let consumes = consumesOpt !== undefined ? consumesOpt : [];
+  let produces = producesOpt !== undefined ? producesOpt : [];
+  let target = targetOpt !== undefined ? Primitive_option.valFromOption(targetOpt) : undefined;
+  return {
+    name: name,
+    consumedEventTypes: consumes,
+    inboundCommandTypes: produces,
+    targetName: target
+  };
+}
+
+function structure(aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChangeSlicesOpt, automationSlicesOpt, outboundTranslationSlicesOpt, inboundTranslationSlicesOpt, extensionPointsOpt) {
+  let aggregates = aggregatesOpt !== undefined ? aggregatesOpt : [];
+  let readModels = readModelsOpt !== undefined ? readModelsOpt : [];
+  let stateViewSlices = stateViewSlicesOpt !== undefined ? stateViewSlicesOpt : [];
+  let stateChangeSlices = stateChangeSlicesOpt !== undefined ? stateChangeSlicesOpt : [];
+  let automationSlices = automationSlicesOpt !== undefined ? automationSlicesOpt : [];
+  let outboundTranslationSlices = outboundTranslationSlicesOpt !== undefined ? outboundTranslationSlicesOpt : [];
+  let inboundTranslationSlices = inboundTranslationSlicesOpt !== undefined ? inboundTranslationSlicesOpt : [];
+  let extensionPoints = extensionPointsOpt !== undefined ? extensionPointsOpt : [];
+  return {
+    readModels: readModels,
+    stateViewSlices: stateViewSlices,
+    stateChangeSlices: stateChangeSlices,
+    aggregates: aggregates,
+    automationSlices: automationSlices,
+    outboundTranslationSlices: outboundTranslationSlices,
+    inboundTranslationSlices: inboundTranslationSlices,
+    extensions: [],
+    extensionPoints: extensionPoints
+  };
+}
+
+function hasEdge(g, from, to, kind) {
+  return g.edges.some(e => {
+    if (e.from === from && e.to === to) {
+      return e.kind === kind;
+    } else {
+      return false;
+    }
+  });
+}
+
+function nodeKind(g, id) {
+  return Stdlib_Option.map(g.nodes.find(n => n.id === id), n => n.kind);
+}
+
+globalThis.describe("DomainGraph.build", () => {
+  globalThis.test("Command → Aggregate → Event → ReadModel (DCB consumedEventTypes)", async () => {
+    let shop = structure([writable("Order", [command("Place", "Shop_Order_Place", undefined)], ["Shop.Placed"], undefined, undefined, undefined)], undefined, [queryable("OrderView", ["Shop.Placed"], undefined)], undefined, undefined, undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "Shop_Order_Place")).toEqual("Command");
+    globalThis.expect(nodeKind(g, "Shop:Order")).toEqual("Aggregate");
+    globalThis.expect(nodeKind(g, "Shop.Placed")).toEqual("Event");
+    globalThis.expect(nodeKind(g, "Shop:OrderView")).toEqual("StateViewSlice");
+    globalThis.expect(hasEdge(g, "Shop_Order_Place", "Shop:Order", "handles")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:Order", "Shop.Placed", "emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:OrderView", "projects")).toBe(true);
+  });
+  globalThis.test("payload-less events (in `events`, not producedEventTypes) still get an emitted node", async () => {
+    let shop = structure([writable("Category", undefined, ["Catalog.Added"], undefined, undefined, [
+        {
+          name: "Added",
+          schema: "",
+          references: []
+        },
+        {
+          name: "Archived",
+          schema: "",
+          references: []
+        }
+      ])], undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "Catalog.Added")).toEqual("Event");
+    globalThis.expect(nodeKind(g, "Catalog.Archived")).toEqual("Event");
+    globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Added", "emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:Category", "Catalog.Archived", "emits")).toBe(true);
+  });
+  globalThis.test("an Internal StateViewSlice still gets a node + projects edge (dev graph shows it)", async () => {
+    let shop = structure([writable("Order", undefined, ["Shop.Placed"], undefined, undefined, undefined)], undefined, [queryable("AvailableView", ["Shop.Placed"], "Internal")], undefined, undefined, undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "Shop:AvailableView")).toEqual("StateViewSlice");
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:AvailableView", "projects")).toBe(true);
+  });
+  globalThis.test("classic linkedViews draws each produced event into the linked read model", async () => {
+    let shop = structure([writable("Order", undefined, [
+        "Shop.Placed",
+        "Shop.Shipped"
+      ], undefined, ["Orders"], undefined)], [queryable("Orders", undefined, undefined)], undefined, undefined, undefined, undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:Orders", "projects")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop.Shipped", "Shop:Orders", "projects")).toBe(true);
+  });
+  globalThis.test("automation slices are triggered by their consumed events", async () => {
+    let shop = structure([writable("Order", undefined, ["Shop.Placed"], undefined, undefined, undefined)], undefined, undefined, undefined, [automation("Notify", ["Shop.Placed"], undefined, undefined)], undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "Shop:Notify")).toEqual("AutomationSlice");
+    globalThis.expect(hasEdge(g, "Shop.Placed", "Shop:Notify", "triggers")).toBe(true);
+  });
+  globalThis.test("an automation routes to the specific command it raises on its target", async () => {
+    let shop = structure(undefined, undefined, undefined, [writable("Ship", [
+        command("ShipOrder", "Shop_Ship_ShipOrder", undefined),
+        command("Place", "Shop_Ship_Place", undefined)
+      ], ["Shop.Shipped"], undefined, undefined, undefined)], [automation("AutoShip", ["Shop.Placed"], ["AutoShip.ShipOrder"], "Ship")], undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_ShipOrder", "delegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:AutoShip", "Shop_Ship_Place", "delegatesTo")).toBe(false);
+  });
+  globalThis.test("an inbound translation routes to the command it raises on its target", async () => {
+    let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Add", "Shop_Product_Add", undefined)], undefined, undefined, undefined, undefined)], undefined, undefined, [inbound("ImportProduct", ["ImportProduct.Add"], "Product")], undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(nodeKind(g, "Shop:ImportProduct")).toEqual("InboundTranslationSlice");
+    globalThis.expect(hasEdge(g, "Shop:ImportProduct", "Shop_Product_Add", "delegatesTo")).toBe(true);
+  });
+  globalThis.test("an outbound translation with a target routes to the command it raises", async () => {
+    let shop = structure(undefined, undefined, undefined, [writable("Product", [command("Sync", "Shop_Product_Sync", undefined)], undefined, undefined, undefined, undefined)], undefined, [outbound("ExportProduct", ["Shop.Added"], ["ExportProduct.Sync"], "Product")], undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(hasEdge(g, "Shop:ExportProduct", "Shop_Product_Sync", "delegatesTo")).toBe(true);
+  });
+  globalThis.test("an event produced by two write-sides is one node with two emit edges", async () => {
+    let shop = structure([
+      writable("A", undefined, ["Shop.Touched"], undefined, undefined, undefined),
+      writable("B", undefined, ["Shop.Touched"], undefined, undefined, undefined)
+    ], undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Shop",
+        shop
+      ]]);
+    globalThis.expect(g.nodes.filter(n => n.id === "Shop.Touched").length).toBe(1);
+    globalThis.expect(hasEdge(g, "Shop:A", "Shop.Touched", "emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Shop:B", "Shop.Touched", "emits")).toBe(true);
+  });
+  globalThis.test("an extension renders the cross-plugin event flow EP→event→Extension→delegate", async () => {
+    let extension_delegateNames = ["ProductDemand"];
+    let extension_eventTypes = ["Ordering.Orders.ItemOrdered"];
+    let extension_commandTypes = [];
+    let extension = {
+      name: "Ordering.Orders",
+      delegateNames: extension_delegateNames,
+      eventTypes: extension_eventTypes,
+      commandTypes: extension_commandTypes
+    };
+    let init = structure([writable("ProductDemand", undefined, ["Catalog.Recorded"], undefined, undefined, undefined)], undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let catalog_readModels = init.readModels;
+    let catalog_stateViewSlices = init.stateViewSlices;
+    let catalog_stateChangeSlices = init.stateChangeSlices;
+    let catalog_aggregates = init.aggregates;
+    let catalog_automationSlices = init.automationSlices;
+    let catalog_outboundTranslationSlices = init.outboundTranslationSlices;
+    let catalog_inboundTranslationSlices = init.inboundTranslationSlices;
+    let catalog_extensions = [extension];
+    let catalog_extensionPoints = init.extensionPoints;
+    let catalog = {
+      readModels: catalog_readModels,
+      stateViewSlices: catalog_stateViewSlices,
+      stateChangeSlices: catalog_stateChangeSlices,
+      aggregates: catalog_aggregates,
+      automationSlices: catalog_automationSlices,
+      outboundTranslationSlices: catalog_outboundTranslationSlices,
+      inboundTranslationSlices: catalog_inboundTranslationSlices,
+      extensions: catalog_extensions,
+      extensionPoints: catalog_extensionPoints
+    };
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        catalog
+      ]]);
+    globalThis.expect(nodeKind(g, "Ordering:ep:Ordering.Orders")).toEqual("ExtensionPoint");
+    globalThis.expect(hasEdge(g, "Ordering:ep:Ordering.Orders", "Ordering.Orders.ItemOrdered", "publishes")).toBe(true);
+    globalThis.expect(hasEdge(g, "Ordering.Orders.ItemOrdered", "Catalog:ext:Ordering.Orders", "consumes")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo")).toBe(true);
+    let protoEvent = Stdlib_Option.getOrThrow(g.nodes.find(n => n.id === "Ordering.Orders.ItemOrdered"), undefined);
+    globalThis.expect(protoEvent.plugin).toBe("");
+    let ext = Stdlib_Option.getOrThrow(g.nodes.find(n => n.id === "Catalog:ext:Ordering.Orders"), undefined);
+    globalThis.expect(ext.label).toBe("Ordering.Orders.Catalog");
+  });
+  globalThis.test("an extension wires to the command(s) it creates, not straight to the delegate", async () => {
+    let extension_delegateNames = ["ProductDemand"];
+    let extension_eventTypes = ["Ordering.Orders.ItemOrdered"];
+    let extension_commandTypes = [];
+    let extension = {
+      name: "Ordering.Orders",
+      delegateNames: extension_delegateNames,
+      eventTypes: extension_eventTypes,
+      commandTypes: extension_commandTypes
+    };
+    let init = structure(undefined, undefined, undefined, [writable("ProductDemand", [command("RecordDemand", "Catalog_ProductDemand_RecordDemand", undefined)], ["Catalog.Recorded"], undefined, undefined, undefined)], undefined, undefined, undefined, undefined);
+    let catalog_readModels = init.readModels;
+    let catalog_stateViewSlices = init.stateViewSlices;
+    let catalog_stateChangeSlices = init.stateChangeSlices;
+    let catalog_aggregates = init.aggregates;
+    let catalog_automationSlices = init.automationSlices;
+    let catalog_outboundTranslationSlices = init.outboundTranslationSlices;
+    let catalog_inboundTranslationSlices = init.inboundTranslationSlices;
+    let catalog_extensions = [extension];
+    let catalog_extensionPoints = init.extensionPoints;
+    let catalog = {
+      readModels: catalog_readModels,
+      stateViewSlices: catalog_stateViewSlices,
+      stateChangeSlices: catalog_stateChangeSlices,
+      aggregates: catalog_aggregates,
+      automationSlices: catalog_automationSlices,
+      outboundTranslationSlices: catalog_outboundTranslationSlices,
+      inboundTranslationSlices: catalog_inboundTranslationSlices,
+      extensions: catalog_extensions,
+      extensionPoints: catalog_extensionPoints
+    };
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        catalog
+      ]]);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog_ProductDemand_RecordDemand", "delegatesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog_ProductDemand_RecordDemand", "Catalog:ProductDemand", "handles")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo")).toBe(false);
+  });
+  globalThis.test("an extension with no commands falls back to delegating to the write-side", async () => {
+    let extension_delegateNames = ["ProductDemand"];
+    let extension_eventTypes = ["Ordering.Orders.ItemOrdered"];
+    let extension_commandTypes = [];
+    let extension = {
+      name: "Ordering.Orders",
+      delegateNames: extension_delegateNames,
+      eventTypes: extension_eventTypes,
+      commandTypes: extension_commandTypes
+    };
+    let init = structure([writable("ProductDemand", undefined, ["Catalog.Recorded"], undefined, undefined, undefined)], undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let catalog_readModels = init.readModels;
+    let catalog_stateViewSlices = init.stateViewSlices;
+    let catalog_stateChangeSlices = init.stateChangeSlices;
+    let catalog_aggregates = init.aggregates;
+    let catalog_automationSlices = init.automationSlices;
+    let catalog_outboundTranslationSlices = init.outboundTranslationSlices;
+    let catalog_inboundTranslationSlices = init.inboundTranslationSlices;
+    let catalog_extensions = [extension];
+    let catalog_extensionPoints = init.extensionPoints;
+    let catalog = {
+      readModels: catalog_readModels,
+      stateViewSlices: catalog_stateViewSlices,
+      stateChangeSlices: catalog_stateChangeSlices,
+      aggregates: catalog_aggregates,
+      automationSlices: catalog_automationSlices,
+      outboundTranslationSlices: catalog_outboundTranslationSlices,
+      inboundTranslationSlices: catalog_inboundTranslationSlices,
+      extensions: catalog_extensions,
+      extensionPoints: catalog_extensionPoints
+    };
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        catalog
+      ]]);
+    globalThis.expect(hasEdge(g, "Catalog:ext:Ordering.Orders", "Catalog:ProductDemand", "delegatesTo")).toBe(true);
+  });
+  globalThis.test("an owned extension point is fed by the producers of its source events", async () => {
+    let ep_delegateNames = ["CatalogDcbEventLog"];
+    let ep_sourceEventTypes = ["Catalog.ProductAdded"];
+    let ep_commandTypes = [];
+    let ep = {
+      name: "Catalog.Products",
+      delegateNames: ep_delegateNames,
+      sourceEventTypes: ep_sourceEventTypes,
+      commandTypes: ep_commandTypes
+    };
+    let catalog = structure(undefined, undefined, undefined, [writable("AddProduct", [command("AddProduct", "Catalog_AddProduct", undefined)], ["Catalog.ProductAdded"], undefined, undefined, undefined)], undefined, undefined, undefined, [ep]);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        catalog
+      ]]);
+    globalThis.expect(nodeKind(g, "Catalog:ep:Catalog.Products")).toEqual("ExtensionPoint");
+    globalThis.expect(hasEdge(g, "Catalog:AddProduct", "Catalog.ProductAdded", "emits")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog.ProductAdded", "Catalog:ep:Catalog.Products", "feeds")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "routesTo")).toBe(false);
+  });
+  globalThis.test("an extension point with an inbound command protocol routes to its delegate's commands", async () => {
+    let ep_delegateNames = ["AddProduct"];
+    let ep_sourceEventTypes = ["Catalog.ProductAdded"];
+    let ep_commandTypes = ["Catalog.Products.RequestAddProduct"];
+    let ep = {
+      name: "Catalog.Products",
+      delegateNames: ep_delegateNames,
+      sourceEventTypes: ep_sourceEventTypes,
+      commandTypes: ep_commandTypes
+    };
+    let catalog = structure(undefined, undefined, undefined, [writable("AddProduct", [command("AddProduct", "Catalog_AddProduct", undefined)], ["Catalog.ProductAdded"], undefined, undefined, undefined)], undefined, undefined, undefined, [ep]);
+    let g = DomainGraph$ReventlessGwt.build([[
+        "Catalog",
+        catalog
+      ]]);
+    globalThis.expect(hasEdge(g, "Catalog:ep:Catalog.Products", "Catalog_AddProduct", "routesTo")).toBe(true);
+    globalThis.expect(hasEdge(g, "Catalog_AddProduct", "Catalog:AddProduct", "handles")).toBe(true);
+  });
+});
+
+export {
+  command,
+  evt,
+  writable,
+  queryable,
+  automation,
+  inbound,
+  outbound,
+  structure,
+  hasEdge,
+  nodeKind,
+}
+/*  Not a pure module */

package/tests/FlowAggregateGwtTest.res

@@ -0,0 +1,169 @@
+// Worked example for Flow_GWT.AggregateCommandStep — two aggregate-style
+// command steps threaded through one shared log. Verifies the framework's
+// new aggregate-ID partitioning:
+//
+//   - Two aggregates sequence cleanly when they share an ID.
+//   - A second aggregate's history is isolated from the first by `~id`, so a
+//     command on `o2` does not see `o1`'s prior events.
+//   - The `Error` branch flows through `thenError` like the slice form.
+
+S.enableJson()
+
+open Flow_GWT
+
+// -- Aggregate: CatalogProduct (one event family, no error) -----------------
+
+module CatalogProductAggregate = {
+  let name = "CatalogProduct"
+
+  @schema
+  type command =
+    | SyncNewProduct({productId: string, name: string})
+
+  @schema
+  type event =
+    | CatalogProductSynced({productId: string, name: string})
+
+  @schema
+  type error = AlreadySynced
+}
+
+module CatalogProductBehavior = {
+  module Spec = CatalogProductAggregate
+
+  type state = NotSynced | Synced
+
+  let initialState = NotSynced
+
+  let evolve = (_state, event: CatalogProductAggregate.event) =>
+    switch event {
+    | CatalogProductSynced(_) => Synced
+    }
+
+  let decide = (state, command: CatalogProductAggregate.command) =>
+    switch (state, command) {
+    | (NotSynced, SyncNewProduct({productId, name})) =>
+      Ok([CatalogProductAggregate.CatalogProductSynced({productId, name})])
+    | (Synced, _) => Error(CatalogProductAggregate.AlreadySynced)
+    }
+
+  let moduleUrl = "test://CatalogProductBehavior"
+}
+
+// -- Aggregate: Order ---------------------------------------------------------
+
+module OrderAggregate = {
+  let name = "Order"
+
+  @schema
+  type command =
+    | Place({customerId: string, productIds: array<string>})
+    | Ship
+
+  @schema
+  type event =
+    | Placed({customerId: string, productIds: array<string>})
+    | Shipped
+
+  @schema
+  type error =
+    | AlreadyPlaced
+    | NotPlaced
+}
+
+module OrderBehavior = {
+  module Spec = OrderAggregate
+
+  type state = {placed: bool, shipped: bool}
+
+  let initialState = {placed: false, shipped: false}
+
+  let evolve = (state, event: OrderAggregate.event) =>
+    switch event {
+    | Placed(_) => {...state, placed: true}
+    | Shipped => {...state, shipped: true}
+    }
+
+  let decide = (state, command: OrderAggregate.command) =>
+    switch command {
+    | Place({customerId, productIds}) =>
+      state.placed
+        ? Error(OrderAggregate.AlreadyPlaced)
+        : Ok([OrderAggregate.Placed({customerId, productIds})])
+    | Ship =>
+      if !state.placed {
+        Error(OrderAggregate.NotPlaced)
+      } else if state.shipped {
+        Ok([])
+      } else {
+        Ok([OrderAggregate.Shipped])
+      }
+    }
+
+  let moduleUrl = "test://OrderBehavior"
+}
+
+// -- Step modules -------------------------------------------------------------
+
+module Sync = AggregateCommandStep(CatalogProductAggregate, CatalogProductBehavior)
+module Place = AggregateCommandStep(OrderAggregate, OrderBehavior)
+
+// -- Flows --------------------------------------------------------------------
+
+describe("Aggregate flow (single plugin)", () => {
+  test("sync product → place order → ship order, threaded through aggregate-ID", () =>
+    start
+    ->Sync.whenCommand(~id="p1", SyncNewProduct({productId: "p1", name: "Book"}))
+    ->Sync.thenEvent(CatalogProductSynced({productId: "p1", name: "Book"}))
+    ->Place.whenCommand(~id="o1", Place({customerId: "c1", productIds: ["p1"]}))
+    ->Place.thenEvent(Placed({customerId: "c1", productIds: ["p1"]}))
+    ->Place.whenCommand(~id="o1", Ship)
+    ->Place.thenEvent(Shipped)
+  )
+
+  test("re-placing the same order is rejected (per-aggregate state replay)", () =>
+    start
+    ->Place.whenCommand(~id="o1", Place({customerId: "c1", productIds: ["p1"]}))
+    ->Place.whenCommand(~id="o1", Place({customerId: "c1", productIds: ["p1"]}))
+    ->Place.thenError(AlreadyPlaced)
+  )
+
+  test("a different order is not blocked by the first (~id isolation)", () =>
+    start
+    ->Place.whenCommand(~id="o1", Place({customerId: "c1", productIds: ["p1"]}))
+    ->Place.thenEvent(Placed({customerId: "c1", productIds: ["p1"]}))
+    ->Place.whenCommand(~id="o2", Place({customerId: "c2", productIds: ["p2"]}))
+    ->Place.thenEvent(Placed({customerId: "c2", productIds: ["p2"]}))
+  )
+
+  test("ship before place returns NotPlaced", () =>
+    start
+    ->Place.whenCommand(~id="o1", Ship)
+    ->Place.thenError(NotPlaced)
+  )
+
+  test("givenEvents seeds history for an ~id starting mid-stream", () =>
+    start
+    ->Place.givenEvents(~id="o1", [Placed({customerId: "c1", productIds: ["p1"]})])
+    ->Place.whenCommand(~id="o1", Ship)
+    ->Place.thenEvent(Shipped)
+  )
+
+  test("ship after ship is idempotent (no events emitted)", () =>
+    start
+    ->Place.whenCommand(~id="o1", Place({customerId: "c1", productIds: ["p1"]}))
+    ->Place.whenCommand(~id="o1", Ship)
+    ->Place.whenCommand(~id="o1", Ship)
+    ->Place.thenNoEvent
+  )
+
+  test("two independent aggregates evolve their own state in parallel", () =>
+    start
+    ->Sync.whenCommand(~id="p1", SyncNewProduct({productId: "p1", name: "Book"}))
+    ->Sync.thenEvent(CatalogProductSynced({productId: "p1", name: "Book"}))
+    ->Sync.whenCommand(~id="p2", SyncNewProduct({productId: "p2", name: "Pen"}))
+    ->Sync.thenEvent(CatalogProductSynced({productId: "p2", name: "Pen"}))
+    ->Sync.whenCommand(~id="p1", SyncNewProduct({productId: "p1", name: "Book"}))
+    ->Sync.thenError(AlreadySynced)
+  )
+})