@reventlessdev/reventless-gwt 1.0.0-alpha.74

package/tests/FlowGwtTest.res

@@ -0,0 +1,222 @@
+// Worked example for Flow_GWT — a single-plugin order flow threaded through a
+// command slice, an automation, a second command slice, a read-model view and
+// an outbound effect. One declarative chain asserts that the slices compose as
+// an Event Modeling lane would draw them.
+//
+// Also exercises DCB tag isolation: a second order is placed successfully even
+// though a first order is already on the shared log, because each command step
+// filters the log by its command's tags.
+// See `docs/plans/done/gwt-flow-and-extension-test-kinds.md` Phase 2.
+
+S.enableJson()
+
+open Flow_GWT
+
+// -- Slices ------------------------------------------------------------------
+
+module PlaceOrderSlice = {
+  let name = "PlaceOrder"
+
+  @schema
+  type consumedEvent = OrderPlaced({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type command = PlaceOrder({orderId: @s.matches(Reventless.DcbTag.string) string, item: string})
+
+  @schema
+  type error = AlreadyPlaced
+
+  @schema
+  type event = OrderPlaced({orderId: @s.matches(Reventless.DcbTag.string) string, item: string})
+}
+
+module PlaceOrderBehavior = {
+  module Spec = PlaceOrderSlice
+  type state = {placed: bool}
+  let initialState = {placed: false}
+
+  let evolve = (_state, event: PlaceOrderSlice.consumedEvent) =>
+    switch event {
+    | OrderPlaced(_) => {placed: true}
+    }
+
+  let decide = (state, command: PlaceOrderSlice.command) =>
+    switch command {
+    | PlaceOrder({orderId, item}) =>
+      state.placed
+        ? Error(PlaceOrderSlice.AlreadyPlaced)
+        : Ok([PlaceOrderSlice.OrderPlaced({orderId, item})])
+    }
+}
+
+module AutoShipSlice = {
+  let name = "AutoShip"
+
+  @schema
+  type consumedEvent =
+    | OrderPlaced({orderId: string})
+    | OrderShipped({orderId: string})
+
+  @schema
+  type todoItem = {orderId: string}
+
+  @schema
+  type command = ShipOrder({orderId: string})
+
+  let collect = event =>
+    switch event {
+    | OrderPlaced({orderId}) => [(orderId, ({orderId: orderId}: todoItem))]
+    | OrderShipped(_) => []
+    }
+
+  let resolve = event =>
+    switch event {
+    | OrderShipped({orderId}) => Some(orderId)
+    | OrderPlaced(_) => None
+    }
+
+  let process = (id, _todo) => Some((id, ShipOrder({orderId: id})))
+}
+
+module ShipOrderSlice = {
+  let name = "ShipOrder"
+
+  @schema
+  type consumedEvent =
+    | OrderPlaced({orderId: @s.matches(Reventless.DcbTag.string) string})
+    | OrderShipped({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type command = ShipOrder({orderId: @s.matches(Reventless.DcbTag.string) string})
+
+  @schema
+  type error = NotPlaced
+
+  @schema
+  type event = OrderShipped({orderId: @s.matches(Reventless.DcbTag.string) string})
+}
+
+module ShipOrderBehavior = {
+  module Spec = ShipOrderSlice
+  type state = {placed: bool, shipped: bool}
+  let initialState = {placed: false, shipped: false}
+
+  let evolve = (state, event: ShipOrderSlice.consumedEvent) =>
+    switch event {
+    | OrderPlaced(_) => {...state, placed: true}
+    | OrderShipped(_) => {...state, shipped: true}
+    }
+
+  let decide = (state, command: ShipOrderSlice.command) =>
+    switch command {
+    | ShipOrder({orderId}) =>
+      if !state.placed {
+        Error(ShipOrderSlice.NotPlaced)
+      } else if state.shipped {
+        Ok([])
+      } else {
+        Ok([ShipOrderSlice.OrderShipped({orderId: orderId})])
+      }
+    }
+}
+
+module OrdersViewSlice = {
+  let name = "OrdersView"
+
+  @schema
+  type state = {orderId: string, item: string, status: string}
+
+  @schema
+  type consumedEvent =
+    | OrderPlaced({orderId: string, item: string})
+    | OrderShipped({orderId: string})
+
+  let subIdConfig = None
+}
+
+module OrdersViewProjection = {
+  module Spec = OrdersViewSlice
+  open Reventless.Projection
+
+  let project = (event: OrdersViewSlice.consumedEvent) =>
+    switch event {
+    | OrderPlaced({orderId, item}) => [
+        Set(orderId, ({orderId, item, status: "Placed"}: OrdersViewSlice.state)),
+      ]
+    | OrderShipped({orderId}) => [Update(orderId, state => {...state, status: "Shipped"})]
+    }
+}
+
+module ConfirmSlice = {
+  let name = "Confirm"
+
+  @schema
+  type consumedEvent = OrderPlaced({orderId: string})
+
+  @schema
+  type outboundItem = {orderId: string}
+
+  @schema
+  type inboundCommand = unit
+
+  let collect = event =>
+    switch event {
+    | OrderPlaced({orderId}) => [(orderId, ({orderId: orderId}: outboundItem))]
+    }
+}
+
+// -- Step modules ------------------------------------------------------------
+
+module Place = CommandStep(PlaceOrderSlice, PlaceOrderBehavior)
+module Auto = AutomationStep(AutoShipSlice)
+module Ship = CommandStep(ShipOrderSlice, ShipOrderBehavior)
+module View = ViewStep(OrdersViewSlice, OrdersViewProjection)
+module Confirm = OutboundStep(ConfirmSlice)
+
+// -- Flows -------------------------------------------------------------------
+
+describe("Order flow (single plugin)", () => {
+  test("place → auto-ship → ship → view Shipped → confirmation fired", () =>
+    start
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", item: "book"}))
+    ->Place.thenEvents([PlaceOrderSlice.OrderPlaced({orderId: "o1", item: "book"})])
+    ->Auto.whenReacts
+    ->Auto.thenIssuesCommand(AutoShipSlice.ShipOrder({orderId: "o1"}))
+    ->Ship.whenCommand(ShipOrderSlice.ShipOrder({orderId: "o1"}))
+    ->Ship.thenEvents([ShipOrderSlice.OrderShipped({orderId: "o1"})])
+    ->View.thenViewState("o1", {OrdersViewSlice.orderId: "o1", item: "book", status: "Shipped"})
+    ->Confirm.thenOutbound([("o1", {ConfirmSlice.orderId: "o1"})])
+  )
+
+  test("automation does not re-issue ShipOrder once the order is shipped", () =>
+    start
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", item: "book"}))
+    ->Ship.whenCommand(ShipOrderSlice.ShipOrder({orderId: "o1"}))
+    ->Auto.whenReacts
+    ->Auto.thenIssuesNoCommand
+  )
+
+  test("re-placing the same order is rejected", () =>
+    start
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", item: "book"}))
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", item: "book"}))
+    ->Place.thenError(AlreadyPlaced)
+  )
+
+  test("a second, different order is not blocked by the first (DCB tag isolation)", () =>
+    start
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", item: "book"}))
+    ->Place.thenEvent(PlaceOrderSlice.OrderPlaced({orderId: "o1", item: "book"}))
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o2", item: "pen"}))
+    ->Place.thenEvent(PlaceOrderSlice.OrderPlaced({orderId: "o2", item: "pen"}))
+  )
+
+  test("shipping one order leaves a sibling order Placed", () =>
+    start
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o1", item: "book"}))
+    ->Place.whenCommand(PlaceOrderSlice.PlaceOrder({orderId: "o2", item: "pen"}))
+    ->Ship.whenCommand(ShipOrderSlice.ShipOrder({orderId: "o1"}))
+    ->View.thenViewState("o1", {OrdersViewSlice.orderId: "o1", item: "book", status: "Shipped"})
+    ->View.thenViewState("o2", {OrdersViewSlice.orderId: "o2", item: "pen", status: "Placed"})
+  )
+})

package/tests/FlowGwtTest.res.mjs

@@ -0,0 +1,432 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Flow_GWT$ReventlessGwt from "../src/Flow_GWT.res.mjs";
+
+S.enableJson();
+
+let consumedEventSchema = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let commandSchema = S.schema(s => ({
+  TAG: "PlaceOrder",
+  orderId: s.m(DcbTag$Reventless.string),
+  item: s.m(S.string)
+}));
+
+let errorSchema = S.literal("AlreadyPlaced");
+
+let eventSchema = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(DcbTag$Reventless.string),
+  item: s.m(S.string)
+}));
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let PlaceOrderSlice = {
+  name: "PlaceOrder",
+  consumedEventSchema: consumedEventSchema,
+  commandSchema: commandSchema,
+  errorSchema: errorSchema,
+  eventSchema: eventSchema,
+  commandAuthorization: commandAuthorization,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState = {
+  placed: false
+};
+
+function evolve(_state, event) {
+  return {
+    placed: true
+  };
+}
+
+function decide(state, command) {
+  if (state.placed) {
+    return {
+      TAG: "Error",
+      _0: "AlreadyPlaced"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "OrderPlaced",
+          orderId: command.orderId,
+          item: command.item
+        }]
+    };
+  }
+}
+
+let PlaceOrderBehavior = {
+  Spec: undefined,
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide
+};
+
+let consumedEventSchema$1 = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let todoItemSchema = S.schema(s => ({
+  orderId: s.m(S.string)
+}));
+
+let commandSchema$1 = S.schema(s => ({
+  TAG: "ShipOrder",
+  orderId: s.m(S.string)
+}));
+
+function collect(event) {
+  if (event.TAG !== "OrderPlaced") {
+    return [];
+  }
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId
+      }
+    ]];
+}
+
+function resolve(event) {
+  if (event.TAG === "OrderPlaced") {
+    return;
+  } else {
+    return event.orderId;
+  }
+}
+
+function process(id, _todo) {
+  return [
+    id,
+    {
+      TAG: "ShipOrder",
+      orderId: id
+    }
+  ];
+}
+
+function commandAuthorization$1(param) {
+  return "AllowAuthenticated";
+}
+
+let AutoShipSlice = {
+  name: "AutoShip",
+  consumedEventSchema: consumedEventSchema$1,
+  todoItemSchema: todoItemSchema,
+  commandSchema: commandSchema$1,
+  collect: collect,
+  resolve: resolve,
+  process: process,
+  commandAuthorization: commandAuthorization$1
+};
+
+let consumedEventSchema$2 = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(DcbTag$Reventless.string)
+  })),
+  S.schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(DcbTag$Reventless.string)
+  }))
+]);
+
+let commandSchema$2 = S.schema(s => ({
+  TAG: "ShipOrder",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+let errorSchema$1 = S.literal("NotPlaced");
+
+let eventSchema$1 = S.schema(s => ({
+  TAG: "OrderShipped",
+  orderId: s.m(DcbTag$Reventless.string)
+}));
+
+function commandAuthorization$2(param) {
+  return "AllowAuthenticated";
+}
+
+let ShipOrderSlice = {
+  name: "ShipOrder",
+  consumedEventSchema: consumedEventSchema$2,
+  commandSchema: commandSchema$2,
+  errorSchema: errorSchema$1,
+  eventSchema: eventSchema$1,
+  commandAuthorization: commandAuthorization$2,
+  readConsistency: "EscalateOnRetry"
+};
+
+let initialState$1 = {
+  placed: false,
+  shipped: false
+};
+
+function evolve$1(state, event) {
+  if (event.TAG === "OrderPlaced") {
+    return {
+      placed: true,
+      shipped: state.shipped
+    };
+  } else {
+    return {
+      placed: state.placed,
+      shipped: true
+    };
+  }
+}
+
+function decide$1(state, command) {
+  if (state.placed) {
+    if (state.shipped) {
+      return {
+        TAG: "Ok",
+        _0: []
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: [{
+            TAG: "OrderShipped",
+            orderId: command.orderId
+          }]
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: "NotPlaced"
+    };
+  }
+}
+
+let ShipOrderBehavior = {
+  Spec: undefined,
+  initialState: initialState$1,
+  evolve: evolve$1,
+  decide: decide$1
+};
+
+let stateSchema = S.schema(s => ({
+  orderId: s.m(S.string),
+  item: s.m(S.string),
+  status: s.m(S.string)
+}));
+
+let consumedEventSchema$3 = S.union([
+  S.schema(s => ({
+    TAG: "OrderPlaced",
+    orderId: s.m(S.string),
+    item: s.m(S.string)
+  })),
+  S.schema(s => ({
+    TAG: "OrderShipped",
+    orderId: s.m(S.string)
+  }))
+]);
+
+let OrdersViewSlice = {
+  name: "OrdersView",
+  stateSchema: stateSchema,
+  consumedEventSchema: consumedEventSchema$3,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+function project(event) {
+  if (event.TAG !== "OrderPlaced") {
+    return [{
+        TAG: "Update",
+        _0: event.orderId,
+        _1: state => ({
+          orderId: state.orderId,
+          item: state.item,
+          status: "Shipped"
+        })
+      }];
+  }
+  let orderId = event.orderId;
+  return [{
+      TAG: "Set",
+      _0: orderId,
+      _1: {
+        orderId: orderId,
+        item: event.item,
+        status: "Placed"
+      }
+    }];
+}
+
+let OrdersViewProjection = {
+  Spec: undefined,
+  project: project
+};
+
+let consumedEventSchema$4 = S.schema(s => ({
+  TAG: "OrderPlaced",
+  orderId: s.m(S.string)
+}));
+
+let outboundItemSchema = S.schema(s => ({
+  orderId: s.m(S.string)
+}));
+
+function collect$1(event) {
+  let orderId = event.orderId;
+  return [[
+      orderId,
+      {
+        orderId: orderId
+      }
+    ]];
+}
+
+let ConfirmSlice = {
+  name: "Confirm",
+  consumedEventSchema: consumedEventSchema$4,
+  outboundItemSchema: outboundItemSchema,
+  inboundCommandSchema: S.unit,
+  collect: collect$1
+};
+
+let Place = Flow_GWT$ReventlessGwt.CommandStep(PlaceOrderSlice)({
+  initialState: initialState,
+  evolve: evolve,
+  decide: decide
+});
+
+let Auto = Flow_GWT$ReventlessGwt.AutomationStep(AutoShipSlice);
+
+let Ship = Flow_GWT$ReventlessGwt.CommandStep(ShipOrderSlice)({
+  initialState: initialState$1,
+  evolve: evolve$1,
+  decide: decide$1
+});
+
+let View = Flow_GWT$ReventlessGwt.ViewStep(OrdersViewSlice)({
+  project: project
+});
+
+let Confirm = Flow_GWT$ReventlessGwt.OutboundStep(ConfirmSlice);
+
+Flow_GWT$ReventlessGwt.describe("Order flow (single plugin)", () => {
+  Flow_GWT$ReventlessGwt.test("place → auto-ship → ship → view Shipped → confirmation fired", undefined, () => Confirm.thenOutbound(View.thenViewState(Ship.thenEvents(Ship.whenCommand(Auto.thenIssuesCommand(Auto.whenReacts(Place.thenEvents(Place.whenCommand(Flow_GWT$ReventlessGwt.start, {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    item: "book"
+  }), [{
+      TAG: "OrderPlaced",
+      orderId: "o1",
+      item: "book"
+    }])), {
+    TAG: "ShipOrder",
+    orderId: "o1"
+  }), {
+    TAG: "ShipOrder",
+    orderId: "o1"
+  }), [{
+      TAG: "OrderShipped",
+      orderId: "o1"
+    }]), "o1", {
+    orderId: "o1",
+    item: "book",
+    status: "Shipped"
+  }), [[
+      "o1",
+      {
+        orderId: "o1"
+      }
+    ]]));
+  Flow_GWT$ReventlessGwt.test("automation does not re-issue ShipOrder once the order is shipped", undefined, () => Auto.thenIssuesNoCommand(Auto.whenReacts(Ship.whenCommand(Place.whenCommand(Flow_GWT$ReventlessGwt.start, {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    item: "book"
+  }), {
+    TAG: "ShipOrder",
+    orderId: "o1"
+  }))));
+  Flow_GWT$ReventlessGwt.test("re-placing the same order is rejected", undefined, () => Place.thenError(Place.whenCommand(Place.whenCommand(Flow_GWT$ReventlessGwt.start, {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    item: "book"
+  }), {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    item: "book"
+  }), "AlreadyPlaced"));
+  Flow_GWT$ReventlessGwt.test("a second, different order is not blocked by the first (DCB tag isolation)", undefined, () => Place.thenEvent(Place.whenCommand(Place.thenEvent(Place.whenCommand(Flow_GWT$ReventlessGwt.start, {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    item: "book"
+  }), {
+    TAG: "OrderPlaced",
+    orderId: "o1",
+    item: "book"
+  }), {
+    TAG: "PlaceOrder",
+    orderId: "o2",
+    item: "pen"
+  }), {
+    TAG: "OrderPlaced",
+    orderId: "o2",
+    item: "pen"
+  }));
+  Flow_GWT$ReventlessGwt.test("shipping one order leaves a sibling order Placed", undefined, () => View.thenViewState(View.thenViewState(Ship.whenCommand(Place.whenCommand(Place.whenCommand(Flow_GWT$ReventlessGwt.start, {
+    TAG: "PlaceOrder",
+    orderId: "o1",
+    item: "book"
+  }), {
+    TAG: "PlaceOrder",
+    orderId: "o2",
+    item: "pen"
+  }), {
+    TAG: "ShipOrder",
+    orderId: "o1"
+  }), "o1", {
+    orderId: "o1",
+    item: "book",
+    status: "Shipped"
+  }), "o2", {
+    orderId: "o2",
+    item: "pen",
+    status: "Placed"
+  }));
+});
+
+export {
+  PlaceOrderSlice,
+  PlaceOrderBehavior,
+  AutoShipSlice,
+  ShipOrderSlice,
+  ShipOrderBehavior,
+  OrdersViewSlice,
+  OrdersViewProjection,
+  ConfirmSlice,
+  Place,
+  Auto,
+  Ship,
+  View,
+  Confirm,
+}
+/*  Not a pure module */

package/tests/FormatterVsCodeMessageTest.res

@@ -0,0 +1,41 @@
+// Unit test for FormatterVsCode.messagePayload — the failure payload the
+// VS Code extension renders. Asserts the `kind` discriminator (the mismatch
+// family) is present so a client can gate the apply-expected quick-fix.
+
+open JestGlobals
+
+let failingResult = (~mismatch): RunnerTypes.testResult => {
+  id: "t1",
+  name: "rejects when category already exists",
+  describePath: [],
+  status: RunnerTypes.Fail,
+  durationMs: 1.0,
+  location: None,
+  slice: None,
+  mismatch,
+  skipReason: None,
+}
+
+describe("FormatterVsCode.messagePayload", () => {
+  testPromise("includes the mismatch kind for an EventsMismatch", async () => {
+    let m = FormatterVsCode.messagePayload(
+      failingResult(~mismatch=Some(Outcome.EventsMismatch({expected: [], actual: []}))),
+    )
+    expect(m.kind)->toEqual(Some("EventsMismatch"))
+  })
+
+  testPromise("includes the mismatch kind for an ErrorMismatch", async () => {
+    let m = FormatterVsCode.messagePayload(
+      failingResult(
+        ~mismatch=Some(
+          Outcome.ErrorMismatch({
+            expected: JSON.String("CategoryAlreadyExists"),
+            actual: None,
+            actualEvents: [],
+          }),
+        ),
+      ),
+    )
+    expect(m.kind)->toEqual(Some("ErrorMismatch"))
+  })
+})