@reventlessdev/reventless-core 3.0.0-alpha.152 → 3.0.0-alpha.154

package/tests/message/MessageTest.res

@@ -93,4 +93,150 @@ describe("Message should", () => {
 
     expect(eventId)->toBe("testId")
   })
+
+  // Schema-migration-on-read: a VersionConnected event persisted before `kind` (and
+  // before later pluginStructure fields like `events`/`chapter`) existed must still
+  // decode — otherwise the one stale event bricks the whole lifecycle aggregate. See
+  // docs/plans/platform-infrastructure-in-plugin-list.md (durable fix option 2).
+  testSync("tolerantly decode a VersionConnected persisted before kind/structure fields existed", () => {
+    open PluginSpec
+    let def: Reventless.Plugin.pluginDefinition = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: None,
+      apiTarget: None,
+      uiFragments: None,
+      structure: Some({
+        readModels: [],
+        stateViewSlices: [],
+        stateChangeSlices: [],
+        aggregates: [
+          {
+            name: "Order",
+            commands: [],
+            producedEventTypes: [],
+            consumedEventTypes: [],
+            linkedViews: [],
+            consistencyRead: None,
+            events: [],
+            chapter: None,
+          },
+        ],
+        automationSlices: [],
+        outboundTranslationSlices: [],
+        inboundTranslationSlices: [],
+        extensions: [],
+        extensionPoints: None,
+      }),
+      dcbEventLog: None,
+      kind: Domain,
+    }
+    let event' = {
+      id: "id",
+      meta: {
+        service: "svc",
+        time: "t",
+        ip: "ip",
+        user: "u",
+        msgId: "m",
+        correlationId: "c",
+      },
+      event: VersionConnected(def),
+    }
+    let json = event'->Message.encodeEvent'(S.string, PluginSpec.eventSchema)
+
+    // Simulate the persisted JSON as written before these fields existed: drop the
+    // mandatory enum `kind`, a top-level `T | null` field, and two nested writableDef
+    // fields (a mandatory array + a `T | null`).
+    let oldJson =
+      %raw(`function(j){
+        var c = JSON.parse(JSON.stringify(j));
+        var d = c.event._0;
+        delete d.kind;
+        delete d.apiSchemaFragment;
+        var agg = d.structure.aggregates[0];
+        delete agg.events;
+        delete agg.chapter;
+        return c;
+      }`)(json)
+
+    // Strict decode must reject the stale JSON — the tolerance is what saves it.
+    let strictThrew = switch oldJson->S.parseJsonOrThrow(
+      Message.toEventSchema'(S.string, PluginSpec.eventSchema),
+    ) {
+    | _ => false
+    | exception _ => true
+    }
+    expect(strictThrew)->toBe(true)
+
+    // Tolerant decode heals: kind -> Domain (first variant), missing array -> [],
+    // missing `T | null` fields -> None.
+    let decoded = oldJson->Message.decodeEvent'(S.string, PluginSpec.eventSchema)
+    switch decoded.event {
+    | VersionConnected(d) =>
+      expect(
+        switch d.kind {
+        | Domain => "Domain"
+        | _ => "other"
+        },
+      )->toBe("Domain")
+      expect(d.apiSchemaFragment->Option.isNone)->toBe(true)
+      let structure: Reventless.Plugin.pluginStructure = d.structure->Option.getOrThrow
+      let agg = structure.aggregates->Array.getUnsafe(0)
+      expect(agg.events->Array.length)->toBe(0)
+      expect(agg.chapter->Option.isNone)->toBe(true)
+    | _ => expect("wrong-variant")->toBe("VersionConnected")
+    }
+  })
+
+  // The exact aggregate-replay path: EventLog_Operations.decodeEvent reassembles the
+  // event variant and calls `Message.decode(Spec.eventSchema)`. This is what actually
+  // bricked in production, so assert `Message.decode` itself heals a stale def.
+  testSync("Message.decode heals a VersionConnected variant missing kind (the replay path)", () => {
+    open PluginSpec
+    let def: Reventless.Plugin.pluginDefinition = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: None,
+      apiTarget: None,
+      uiFragments: None,
+      structure: None,
+      dcbEventLog: None,
+      kind: Domain,
+    }
+    let variantJson = VersionConnected(def)->Message.encode(PluginSpec.eventSchema)
+    let staleJson =
+      %raw(`function(j){ var c = JSON.parse(JSON.stringify(j)); delete c._0.kind; return c; }`)(
+        variantJson,
+      )
+
+    // Strict decode of the stale variant throws (reproduces the production brick).
+    let strictThrew = switch staleJson->S.parseJsonOrThrow(PluginSpec.eventSchema) {
+    | _ => false
+    | exception _ => true
+    }
+    expect(strictThrew)->toBe(true)
+
+    // The replay decoder heals kind -> Domain.
+    switch staleJson->Message.decode(PluginSpec.eventSchema) {
+    | VersionConnected(d) =>
+      expect(
+        switch d.kind {
+        | Domain => "Domain"
+        | _ => "other"
+        },
+      )->toBe("Domain")
+    | _ => expect("wrong-variant")->toBe("VersionConnected")
+    }
+  })
 })

package/tests/message/MessageTest.res.mjs

@@ -89,6 +89,133 @@ globalThis.describe("Message should", () => {
     let eventId = Stdlib_Option.getOrThrow(Message$ReventlessCore.idOfEvent$pJson(eventJson$p), undefined);
     globalThis.expect(eventId).toBe("testId");
   });
+  globalThis.test("tolerantly decode a VersionConnected persisted before kind/structure fields existed", () => {
+    let def = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: undefined,
+      apiTarget: undefined,
+      uiFragments: undefined,
+      structure: {
+        readModels: [],
+        stateViewSlices: [],
+        stateChangeSlices: [],
+        aggregates: [{
+            name: "Order",
+            commands: [],
+            producedEventTypes: [],
+            consumedEventTypes: [],
+            linkedViews: [],
+            consistencyRead: undefined,
+            events: [],
+            chapter: undefined
+          }],
+        automationSlices: [],
+        outboundTranslationSlices: [],
+        inboundTranslationSlices: [],
+        extensions: [],
+        extensionPoints: undefined
+      },
+      dcbEventLog: undefined,
+      kind: "Domain"
+    };
+    let event$p_meta = {
+      service: "svc",
+      time: "t",
+      ip: "ip",
+      user: "u",
+      msgId: "m",
+      correlationId: "c"
+    };
+    let event$p_event = {
+      TAG: "VersionConnected",
+      _0: def
+    };
+    let event$p = {
+      id: "id",
+      meta: event$p_meta,
+      event: event$p_event
+    };
+    let json = Message$ReventlessCore.encodeEvent$p(event$p, S.string, PluginSpec$ReventlessCore.eventSchema);
+    let oldJson = (function(j){
+        var c = JSON.parse(JSON.stringify(j));
+        var d = c.event._0;
+        delete d.kind;
+        delete d.apiSchemaFragment;
+        var agg = d.structure.aggregates[0];
+        delete agg.events;
+        delete agg.chapter;
+        return c;
+      })(json);
+    let strictThrew;
+    try {
+      S.parseJsonOrThrow(oldJson, Message$ReventlessCore.toEventSchema$p(S.string, PluginSpec$ReventlessCore.eventSchema));
+      strictThrew = false;
+    } catch (exn) {
+      strictThrew = true;
+    }
+    globalThis.expect(strictThrew).toBe(true);
+    let decoded = Message$ReventlessCore.decodeEvent$p(oldJson, S.string, PluginSpec$ReventlessCore.eventSchema);
+    let d = decoded.event;
+    if (d.TAG === "VersionConnected") {
+      let d$1 = d._0;
+      let match = d$1.kind;
+      let tmp;
+      tmp = match === "Domain" ? "Domain" : "other";
+      globalThis.expect(tmp).toBe("Domain");
+      globalThis.expect(Stdlib_Option.isNone(d$1.apiSchemaFragment)).toBe(true);
+      let structure = Stdlib_Option.getOrThrow(d$1.structure, undefined);
+      let agg = structure.aggregates[0];
+      globalThis.expect(agg.events.length).toBe(0);
+      globalThis.expect(Stdlib_Option.isNone(agg.chapter)).toBe(true);
+      return;
+    }
+    globalThis.expect("wrong-variant").toBe("VersionConnected");
+  });
+  globalThis.test("Message.decode heals a VersionConnected variant missing kind (the replay path)", () => {
+    let def = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: undefined,
+      apiTarget: undefined,
+      uiFragments: undefined,
+      structure: undefined,
+      dcbEventLog: undefined,
+      kind: "Domain"
+    };
+    let variantJson = Message$ReventlessCore.encode({
+      TAG: "VersionConnected",
+      _0: def
+    }, PluginSpec$ReventlessCore.eventSchema);
+    let staleJson = (function(j){ var c = JSON.parse(JSON.stringify(j)); delete c._0.kind; return c; })(variantJson);
+    let strictThrew;
+    try {
+      S.parseJsonOrThrow(staleJson, PluginSpec$ReventlessCore.eventSchema);
+      strictThrew = false;
+    } catch (exn) {
+      strictThrew = true;
+    }
+    globalThis.expect(strictThrew).toBe(true);
+    let d = Message$ReventlessCore.decode(staleJson, PluginSpec$ReventlessCore.eventSchema);
+    if (d.TAG === "VersionConnected") {
+      let match = d._0.kind;
+      let tmp;
+      tmp = match === "Domain" ? "Domain" : "other";
+      globalThis.expect(tmp).toBe("Domain");
+      return;
+    }
+    globalThis.expect("wrong-variant").toBe("VersionConnected");
+  });
 });
 
 /*  Not a pure module */

package/tests/plugin/ManifestVisibilityTest.res.mjs

@@ -177,7 +177,7 @@ globalThis.describe("ReadModel visibility filter", () => {
 });
 
 globalThis.describe("Plugin_Structure.make — visibility tagging", () => {
-  let structure = Plugin_Structure$ReventlessCore.make("VisibilityPlugin", undefined, readModels, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  let structure = Plugin_Structure$ReventlessCore.make("VisibilityPlugin", undefined, readModels, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
   globalThis.test("readModels carries both Public and Internal entries", () => {
     globalThis.expect(structure.readModels.length).toBe(2);
   });

package/tests/plugin/PluginStructureTest.res

@@ -295,4 +295,38 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       )->toBe(None)
     })
   })
+
+  // The generator captures each component's chapter (source-folder grouping band)
+  // and passes it as ~componentChapters; Plugin_Structure looks it up by Spec.name
+  // and threads it onto every def, so a deployed-graph consumer can render chapter
+  // bands without workspace access. See docs/plans/deployed-chapter-grouping.md.
+  describe("componentChapters threading", () => {
+    let chaptered = Plugin_Structure.make(
+      ~name="TestPlugin",
+      ~stateChangeSlices=[module(PsPlaceOrderSlice), module(PsShipOrderSlice)],
+      ~stateViewSlices=[module(PsOrdersViewSlice)],
+      // PlaceOrder + Orders live under a chapter; ShipOrder does not.
+      ~componentChapters=Dict.fromArray([("PlaceOrder", "Order"), ("Orders", "Order")]),
+    )
+
+    testSync("a chaptered state-change slice carries Some(chapter)", () => {
+      let placeOrder = chaptered.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.chapter)->toEqual(Some("Order"))
+    })
+
+    testSync("a chaptered state-view slice carries Some(chapter)", () => {
+      let orders = chaptered.stateViewSlices->Array.getUnsafe(0)
+      expect(orders.chapter)->toEqual(Some("Order"))
+    })
+
+    testSync("a component absent from the map carries None", () => {
+      let shipOrder = chaptered.stateChangeSlices->Array.getUnsafe(1)
+      expect(shipOrder.chapter)->toEqual(None)
+    })
+
+    testSync("no ~componentChapters → every def is chapterless (None)", () => {
+      let placeOrder = structure.stateChangeSlices->Array.getUnsafe(0)
+      expect(placeOrder.chapter)->toEqual(None)
+    })
+  })
 })

package/tests/plugin/PluginStructureTest.res.mjs

@@ -183,7 +183,7 @@ let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, un
 ], [
   PsPlaceOrderSlice,
   PsShipOrderSlice
-], undefined, undefined, undefined, undefined, undefined);
+], undefined, undefined, undefined, undefined, undefined, undefined);
 
 globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
   globalThis.describe("stateChangeSlices", () => {
@@ -374,6 +374,37 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       globalThis.expect(Stdlib_Option.flatMap(orderIdField, s => getProperty(s, "x-reventless-id"))).toBe(undefined);
     });
   });
+  globalThis.describe("componentChapters threading", () => {
+    let chaptered = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [PsOrdersViewSlice], [
+      PsPlaceOrderSlice,
+      PsShipOrderSlice
+    ], undefined, undefined, undefined, undefined, undefined, Object.fromEntries([
+      [
+        "PlaceOrder",
+        "Order"
+      ],
+      [
+        "Orders",
+        "Order"
+      ]
+    ]));
+    globalThis.test("a chaptered state-change slice carries Some(chapter)", () => {
+      let placeOrder = chaptered.stateChangeSlices[0];
+      globalThis.expect(placeOrder.chapter).toEqual("Order");
+    });
+    globalThis.test("a chaptered state-view slice carries Some(chapter)", () => {
+      let orders = chaptered.stateViewSlices[0];
+      globalThis.expect(orders.chapter).toEqual("Order");
+    });
+    globalThis.test("a component absent from the map carries None", () => {
+      let shipOrder = chaptered.stateChangeSlices[1];
+      globalThis.expect(shipOrder.chapter).toEqual(undefined);
+    });
+    globalThis.test("no ~componentChapters → every def is chapterless (None)", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      globalThis.expect(placeOrder.chapter).toEqual(undefined);
+    });
+  });
 });
 
 export {