@reventlessdev/reventless-core 3.0.0-alpha.258 → 3.0.0-alpha.260

package/tests/projection/LifecycleTrailTest.res

@@ -0,0 +1,139 @@
+// The rule that fills a lifecycle trail: an action that moves a view's
+// lifecycle field appends `{state, at}`, and nothing else does. The example GWTs
+// cover the same rule end to end, but their harness stamps one fixed producer
+// time — the ordering-with-distinct-instants cases have to live here.
+
+open JestGlobals
+open Reventless.Projection
+
+@schema
+type lifecycle =
+  | Placed
+  | Shipped
+  | Cancelled
+
+@schema
+type order = {
+  orderId: string,
+  lifecycle: lifecycle,
+  trail: Reventless.Lifecycle.Trail.t<lifecycle>,
+}
+
+// A view that declares no trail, to hold the "nothing changes" case.
+@schema
+type plain = {
+  orderId: string,
+  lifecycle: lifecycle,
+}
+
+let nine = "2026-03-02T09:00:00Z"
+let ten = "2026-03-02T10:00:00Z"
+let eleven = "2026-03-02T11:00:00Z"
+
+let placed = {orderId: "o1", lifecycle: Placed, trail: []}
+
+// Applies one action to a state, the way the runtime does: `Set` writes the
+// state it carries, `Update` runs its function over what is there.
+let apply = (state: option<order>, action: action<string, order>): option<order> =>
+  switch (action, state) {
+  | (Set(_, s), _) | (Create(_, s), _) => Some(s)
+  | (Update(_, fn), Some(s)) => Some(fn(s))
+  | _ => state
+  }
+
+let run = (actions: array<(string, action<string, order>)>) =>
+  actions->Array.reduce(None, (state, (at, action)) =>
+    state->apply(Projection.rewriteAction(action, ~at, orderSchema))
+  )
+
+let statesOf = (state: option<order>) =>
+  state->Option.mapOr([], s => s.trail->Array.map(entry => (entry.state, entry.at)))
+
+describe("the lifecycle trail:", () => {
+  testSync("opens with the state the row was created in", () =>
+    expect(run([(nine, Set("o1", placed))])->statesOf)->toEqual([(Placed, nine)])
+  )
+
+  testSync("appends one entry per transition, in order", () =>
+    expect(
+      run([
+        (nine, Set("o1", placed)),
+        (ten, Update("o1", s => {...s, lifecycle: Shipped})),
+      ])->statesOf,
+    )->toEqual([(Placed, nine), (Shipped, ten)])
+  )
+
+  // The case a `dict<state, instant>` cannot hold: a reopened order is `Placed`
+  // twice, at different instants, and both visits are facts about the row.
+  testSync("keeps both visits when a lifecycle revisits a state", () =>
+    expect(
+      run([
+        (nine, Set("o1", placed)),
+        (ten, Update("o1", s => {...s, lifecycle: Cancelled})),
+        (eleven, Update("o1", s => {...s, lifecycle: Placed})),
+      ])->statesOf,
+    )->toEqual([(Placed, nine), (Cancelled, ten), (Placed, eleven)])
+  )
+
+  testSync("appends nothing for an update that leaves the lifecycle alone", () =>
+    expect(
+      run([
+        (nine, Set("o1", placed)),
+        (ten, Update("o1", s => {...s, orderId: "o1-renamed"})),
+      ])->statesOf,
+    )->toEqual([(Placed, nine)])
+  )
+
+  // Derived from the log and the envelope's own time, so the same events in the
+  // same order produce the same trail however often they are replayed.
+  testSync("a rebuild from the same events produces an identical trail", () => {
+    let events = [
+      (nine, Set("o1", placed)),
+      (ten, Update("o1", s => {...s, lifecycle: Shipped})),
+    ]
+    expect(run(events)->statesOf)->toEqual(run(events)->statesOf)
+  })
+
+  // The marker is what makes a trail recognisable to a consumer holding only the
+  // schema. `SchemaType.trailShape` walks the entries by shape, which skips the
+  // semantic dispatch `fromSury` does, so this is the assertion that catches it
+  // being dropped there — the field would still emit as a plain array of objects.
+  testSync("carries the lifecycleTrail semantic onto the emitted JSON Schema", () => {
+    let field =
+      SuryToJsonSchema.deriveObjectSchema(~typeName="Order", orderSchema->S.castToUnknown)
+      ->JSON.Decode.object
+      ->Option.flatMap(o => o->Dict.get("properties"))
+      ->Option.flatMap(JSON.Decode.object)
+      ->Option.flatMap(p => p->Dict.get("trail"))
+      ->Option.flatMap(JSON.Decode.object)
+    expect(field->Option.flatMap(f => f->Dict.get("x-reventless-semantic")))->toEqual(
+      Some(JSON.Encode.string("lifecycleTrail")),
+    )
+  })
+
+  // One vocabulary, published once: the entry's state resolves to the enum the
+  // lifecycle field already emits, not a second copy under the trail's own path.
+  testSync("names the entry's state after the record's own lifecycle enum", () => {
+    let fields = SchemaType.fromSuryObject(~typeName="Order", orderSchema->S.castToUnknown)
+    let enumName = switch fields->Option.flatMap(f => f->Dict.get("trail")) {
+    | Some(Semantic(_, ArrayOf(ObjectRef(_, entry)))) =>
+      switch entry->Dict.get("state") {
+      | Some(Enum(name, _)) => Some(name)
+      | _ => None
+      }
+    | _ => None
+    }
+    expect(enumName)->toEqual(Some("OrderLifecycle"))
+  })
+
+  testSync("a view that declares no trail is projected unchanged", () => {
+    let action: action<string, plain> = Set("o1", {orderId: "o1", lifecycle: Placed})
+    let rewritten = Projection.rewriteAction(action, ~at=nine, plainSchema)
+    expect(
+      switch rewritten {
+      | Set(id, s) => Some((id, s.lifecycle))
+      | _ => None
+      },
+    )->toEqual(Some(("o1", Placed)))
+  })
+})

package/tests/projection/LifecycleTrailTest.res.mjs

@@ -0,0 +1,280 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
+import * as Projection$ReventlessCore from "../../src/Projection.res.mjs";
+import * as SchemaType$ReventlessCore from "../../src/components/Api/SchemaType.res.mjs";
+import * as SuryToJsonSchema$ReventlessCore from "../../src/components/Api/SuryToJsonSchema.res.mjs";
+
+let lifecycleSchema = Sury.union([
+  Sury.literal("Placed"),
+  Sury.literal("Shipped"),
+  Sury.literal("Cancelled")
+]);
+
+let orderSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  lifecycle: s.m(lifecycleSchema),
+  trail: s.m(Lifecycle$Reventless.Trail.schema(lifecycleSchema))
+}));
+
+let plainSchema = Sury.$schema(s => ({
+  orderId: s.m(Sury.string),
+  lifecycle: s.m(lifecycleSchema)
+}));
+
+let nine = "2026-03-02T09:00:00Z";
+
+let ten = "2026-03-02T10:00:00Z";
+
+let eleven = "2026-03-02T11:00:00Z";
+
+let placed_trail = [];
+
+let placed = {
+  orderId: "o1",
+  lifecycle: "Placed",
+  trail: placed_trail
+};
+
+function apply(state, action) {
+  if (typeof action !== "object") {
+    return state;
+  }
+  switch (action.TAG) {
+    case "Update" :
+      if (state !== undefined) {
+        return action._1(state);
+      } else {
+        return state;
+      }
+    case "Create" :
+    case "Set" :
+      return action._1;
+    default:
+      return state;
+  }
+}
+
+function run(actions) {
+  return Stdlib_Array.reduce(actions, undefined, (state, param) => apply(state, Projection$ReventlessCore.rewriteAction(param[1], param[0], orderSchema)));
+}
+
+function statesOf(state) {
+  return Stdlib_Option.mapOr(state, [], s => s.trail.map(entry => [
+    entry.state,
+    entry.at
+  ]));
+}
+
+globalThis.describe("the lifecycle trail:", () => {
+  globalThis.test("opens with the state the row was created in", () => {
+    globalThis.expect(statesOf(run([[
+        nine,
+        {
+          TAG: "Set",
+          _0: "o1",
+          _1: placed
+        }
+      ]]))).toEqual([[
+        "Placed",
+        nine
+      ]]);
+  });
+  globalThis.test("appends one entry per transition, in order", () => {
+    globalThis.expect(statesOf(run([
+      [
+        nine,
+        {
+          TAG: "Set",
+          _0: "o1",
+          _1: placed
+        }
+      ],
+      [
+        ten,
+        {
+          TAG: "Update",
+          _0: "o1",
+          _1: s => ({
+            orderId: s.orderId,
+            lifecycle: "Shipped",
+            trail: s.trail
+          })
+        }
+      ]
+    ]))).toEqual([
+      [
+        "Placed",
+        nine
+      ],
+      [
+        "Shipped",
+        ten
+      ]
+    ]);
+  });
+  globalThis.test("keeps both visits when a lifecycle revisits a state", () => {
+    globalThis.expect(statesOf(run([
+      [
+        nine,
+        {
+          TAG: "Set",
+          _0: "o1",
+          _1: placed
+        }
+      ],
+      [
+        ten,
+        {
+          TAG: "Update",
+          _0: "o1",
+          _1: s => ({
+            orderId: s.orderId,
+            lifecycle: "Cancelled",
+            trail: s.trail
+          })
+        }
+      ],
+      [
+        eleven,
+        {
+          TAG: "Update",
+          _0: "o1",
+          _1: s => ({
+            orderId: s.orderId,
+            lifecycle: "Placed",
+            trail: s.trail
+          })
+        }
+      ]
+    ]))).toEqual([
+      [
+        "Placed",
+        nine
+      ],
+      [
+        "Cancelled",
+        ten
+      ],
+      [
+        "Placed",
+        eleven
+      ]
+    ]);
+  });
+  globalThis.test("appends nothing for an update that leaves the lifecycle alone", () => {
+    globalThis.expect(statesOf(run([
+      [
+        nine,
+        {
+          TAG: "Set",
+          _0: "o1",
+          _1: placed
+        }
+      ],
+      [
+        ten,
+        {
+          TAG: "Update",
+          _0: "o1",
+          _1: s => ({
+            orderId: "o1-renamed",
+            lifecycle: s.lifecycle,
+            trail: s.trail
+          })
+        }
+      ]
+    ]))).toEqual([[
+        "Placed",
+        nine
+      ]]);
+  });
+  globalThis.test("a rebuild from the same events produces an identical trail", () => {
+    let events = [
+      [
+        nine,
+        {
+          TAG: "Set",
+          _0: "o1",
+          _1: placed
+        }
+      ],
+      [
+        ten,
+        {
+          TAG: "Update",
+          _0: "o1",
+          _1: s => ({
+            orderId: s.orderId,
+            lifecycle: "Shipped",
+            trail: s.trail
+          })
+        }
+      ]
+    ];
+    globalThis.expect(statesOf(run(events))).toEqual(statesOf(run(events)));
+  });
+  globalThis.test("carries the lifecycleTrail semantic onto the emitted JSON Schema", () => {
+    let field = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, "Order", orderSchema)), o => o["properties"]), Stdlib_JSON.Decode.object), p => p["trail"]), Stdlib_JSON.Decode.object);
+    globalThis.expect(Stdlib_Option.flatMap(field, f => f["x-reventless-semantic"])).toEqual("lifecycleTrail");
+  });
+  globalThis.test("names the entry's state after the record's own lifecycle enum", () => {
+    let fields = SchemaType$ReventlessCore.fromSuryObject("Order", orderSchema);
+    let match = Stdlib_Option.flatMap(fields, f => f["trail"]);
+    let enumName;
+    if (typeof match === "object" && match.TAG === "Semantic") {
+      let match$1 = match._1;
+      if (typeof match$1 !== "object" || match$1.TAG !== "ArrayOf") {
+        enumName = undefined;
+      } else {
+        let match$2 = match$1._0;
+        if (typeof match$2 !== "object" || match$2.TAG !== "ObjectRef") {
+          enumName = undefined;
+        } else {
+          let match$3 = match$2._1["state"];
+          enumName = typeof match$3 === "object" && match$3.TAG === "Enum" ? match$3._0 : undefined;
+        }
+      }
+    } else {
+      enumName = undefined;
+    }
+    globalThis.expect(enumName).toEqual("OrderLifecycle");
+  });
+  globalThis.test("a view that declares no trail is projected unchanged", () => {
+    let rewritten = Projection$ReventlessCore.rewriteAction({
+      TAG: "Set",
+      _0: "o1",
+      _1: {
+        orderId: "o1",
+        lifecycle: "Placed"
+      }
+    }, nine, plainSchema);
+    let tmp;
+    tmp = typeof rewritten !== "object" || rewritten.TAG !== "Set" ? undefined : [
+        rewritten._0,
+        rewritten._1.lifecycle
+      ];
+    globalThis.expect(tmp).toEqual([
+      "o1",
+      "Placed"
+    ]);
+  });
+});
+
+export {
+  lifecycleSchema,
+  orderSchema,
+  plainSchema,
+  nine,
+  ten,
+  eleven,
+  placed,
+  apply,
+  run,
+  statesOf,
+}
+/* lifecycleSchema Not a pure module */