@reventlessdev/reventless-local 3.0.0-alpha.199 → 3.0.0-alpha.201

package/src/reset/LocalSeedReset.res.mjs

@@ -0,0 +1,533 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+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 Offload$Reventless from "@reventlessdev/reventless-spec/src/semantic/Offload.res.mjs";
+import * as Backend$ReventlessLocal from "../adapter/Backend.res.mjs";
+import * as PluginSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginSpec.res.mjs";
+import * as Seed_Prompt$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Prompt.res.mjs";
+import * as UiFragments$ReventlessCore from "@reventlessdev/reventless-core/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as SqliteDriver$ReventlessLocal from "../adapter/SqliteDriver.res.mjs";
+import * as LocalObjectStore$ReventlessLocal from "../adapter/ObjectStore/LocalObjectStore.res.mjs";
+import * as PluginsReadModelSpec$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsReadModelSpec.res.mjs";
+import * as ObjectStoreStorage_FileSystem$ReventlessLocal from "../adapter/ObjectStore/ObjectStoreStorage_FileSystem.res.mjs";
+
+function scopeLabel(s) {
+  if (typeof s === "object") {
+    return s._0;
+  }
+  switch (s) {
+    case "Domain" :
+      return "domain";
+    case "Platform" :
+      return "platform";
+    case "Everything" :
+      return "everything";
+  }
+}
+
+let platformQueryables = [
+  PluginsReadModelSpec$ReventlessCore.name,
+  UiFragments$ReventlessCore.name
+];
+
+let platformWritables = [PluginSpec$ReventlessCore.name];
+
+function qdbTableName(name) {
+  return "qdb_" + name.replaceAll("-", "_");
+}
+
+function aggregateLogName(name) {
+  return ComponentType$ReventlessCore.name(ComponentType$ReventlessCore.name(name, "Aggregate"), "EventLog");
+}
+
+function checkpointComponent(readModel) {
+  let withoutDcb = readModel.startsWith("dcb:") ? readModel.slice("dcb:".length, readModel.length) : readModel;
+  let withoutColl = withoutDcb.endsWith("EventColl") ? withoutDcb.slice(0, withoutDcb.length - "EventColl".length | 0) : withoutDcb;
+  if (withoutColl.endsWith("ReadModel")) {
+    return withoutColl.slice(0, withoutColl.length - "ReadModel".length | 0);
+  } else {
+    return withoutColl;
+  }
+}
+
+function tableExists(db, name) {
+  return Stdlib_Option.isSome(SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"), [name]));
+}
+
+function strings(rows, column) {
+  return Stdlib_Array.filterMap(rows, row => {
+    let match = row[column];
+    if (typeof match === "string") {
+      return match;
+    }
+  });
+}
+
+function qdbTables(db) {
+  return strings(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'qdb\\_%' ESCAPE '\\' ORDER BY name"), []), "name");
+}
+
+function distinct(db, table, column) {
+  if (tableExists(db, table)) {
+    return strings(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, `SELECT DISTINCT ` + column + ` AS v FROM ` + table + ` ORDER BY v`), []), "v");
+  } else {
+    return [];
+  }
+}
+
+function countWhere(db, table, column, value) {
+  if (!tableExists(db, table)) {
+    return 0;
+  }
+  let row = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, `SELECT COUNT(*) AS c FROM ` + table + ` WHERE ` + column + ` = ?`), [value]);
+  if (row === undefined) {
+    return 0;
+  }
+  let match = row["c"];
+  if (typeof match === "number") {
+    return match | 0;
+  } else {
+    return 0;
+  }
+}
+
+function countAll(db, table) {
+  if (!tableExists(db, table)) {
+    return 0;
+  }
+  let row = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, `SELECT COUNT(*) AS c FROM ` + table), []);
+  if (row === undefined) {
+    return 0;
+  }
+  let match = row["c"];
+  if (typeof match === "number") {
+    return match | 0;
+  } else {
+    return 0;
+  }
+}
+
+function namesIn(structure, field) {
+  let match = structure[field];
+  if (match !== undefined) {
+    if (Array.isArray(match)) {
+      return Stdlib_Array.filterMap(match, item => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+          return;
+        }
+        let match = item["name"];
+        if (typeof match === "string") {
+          return match;
+        }
+      });
+    } else {
+      return [];
+    }
+  } else {
+    return [];
+  }
+}
+
+function resolveStructure(root, json) {
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    return;
+  }
+  let match = json[Offload$Reventless.sentinelKey];
+  if (match === undefined) {
+    return json;
+  }
+  if (typeof match !== "object" || match === null || Array.isArray(match)) {
+    return json;
+  }
+  let match$1 = match["key"];
+  if (typeof match$1 === "string") {
+    return Stdlib_Option.flatMap(ObjectStoreStorage_FileSystem$ReventlessLocal.getOffload(root, match$1), bytes => {
+      let resolved;
+      try {
+        resolved = JSON.parse(bytes);
+      } catch (exn) {
+        resolved = null;
+      }
+      if (typeof resolved === "object" && resolved !== null && !Array.isArray(resolved)) {
+        return resolved;
+      }
+    });
+  }
+}
+
+function readPlugins(db, root) {
+  let table = qdbTableName(PluginsReadModelSpec$ReventlessCore.name);
+  if (tableExists(db, table)) {
+    return Stdlib_Array.filterMap(SqliteDriver$ReventlessLocal.all(SqliteDriver$ReventlessLocal.prepare(db, `SELECT partition_key, item FROM ` + table), []), row => {
+      let match = row["partition_key"];
+      let match$1 = row["item"];
+      if (match === undefined) {
+        return;
+      }
+      if (typeof match !== "string") {
+        return;
+      }
+      if (match$1 === undefined) {
+        return;
+      }
+      if (typeof match$1 !== "string") {
+        return;
+      }
+      let o;
+      try {
+        o = JSON.parse(match$1);
+      } catch (exn) {
+        o = null;
+      }
+      if (typeof o === "object" && o !== null && !Array.isArray(o)) {
+        return Stdlib_Option.map(Stdlib_Option.flatMap(o["structure"], s => resolveStructure(root, s)), structure => {
+          let match$2 = structure["requiredStores"];
+          let tmp;
+          tmp = match$2 !== undefined ? (
+              Array.isArray(match$2) ? Stdlib_Array.filterMap(match$2, i => {
+                  if (typeof i === "string") {
+                    return i;
+                  }
+                }) : []
+            ) : [];
+          return {
+            plugin: match,
+            queryables: namesIn(structure, "readModels").concat(namesIn(structure, "stateViewSlices")),
+            writables: namesIn(structure, "aggregates").concat(namesIn(structure, "stateChangeSlices")),
+            stores: tmp
+          };
+        });
+      }
+    });
+  } else {
+    return [];
+  }
+}
+
+function total(p) {
+  return Stdlib_Array.reduce(p.items, 0, (sum, i) => sum + i.count | 0);
+}
+
+function deleteWhere(db, table, column, value) {
+  if (tableExists(db, table)) {
+    return SqliteDriver$ReventlessLocal.run(SqliteDriver$ReventlessLocal.prepare(db, `DELETE FROM ` + table + ` WHERE ` + column + ` = ?`), [value]);
+  }
+}
+
+function clearTable(db, table) {
+  if (tableExists(db, table)) {
+    return SqliteDriver$ReventlessLocal.exec(db, `DELETE FROM ` + table);
+  }
+}
+
+function build(db, root, scope) {
+  let plugins = readPlugins(db, root);
+  let platformQdb = platformQueryables.map(qdbTableName);
+  let platformLogs = platformWritables.map(aggregateLogName);
+  let selectedPlugins;
+  if (typeof scope !== "object") {
+    switch (scope) {
+      case "Platform" :
+        selectedPlugins = [];
+        break;
+      case "Domain" :
+      case "Everything" :
+        selectedPlugins = plugins;
+        break;
+    }
+  } else {
+    let name = scope._0;
+    selectedPlugins = plugins.filter(p => p.plugin === name);
+  }
+  let claimsQdb = table => {
+    if (typeof scope === "object") {
+      return selectedPlugins.some(p => p.queryables.some(q => qdbTableName(q) === table));
+    }
+    switch (scope) {
+      case "Domain" :
+        return !platformQdb.includes(table);
+      case "Platform" :
+        return platformQdb.includes(table);
+      case "Everything" :
+        return true;
+    }
+  };
+  let claimsLog = log => {
+    if (typeof scope === "object") {
+      return selectedPlugins.some(p => p.writables.some(w => {
+        if (aggregateLogName(w) === log) {
+          return true;
+        } else {
+          return w === log;
+        }
+      }));
+    }
+    switch (scope) {
+      case "Domain" :
+        return !platformLogs.includes(log);
+      case "Platform" :
+        return platformLogs.includes(log);
+      case "Everything" :
+        return true;
+    }
+  };
+  let claimedQdb = qdbTables(db).filter(claimsQdb);
+  let claimedComponents = claimedQdb.map(t => t.slice("qdb_".length, t.length));
+  let items = [];
+  claimedQdb.forEach(table => {
+    items.push({
+      label: table,
+      count: countAll(db, table),
+      run: () => clearTable(db, table)
+    });
+  });
+  [
+    "event_log",
+    "snapshot"
+  ].forEach(table => {
+    distinct(db, table, "log_name").filter(claimsLog).forEach(log => {
+      items.push({
+        label: table + ` (` + log + `)`,
+        count: countWhere(db, table, "log_name", log),
+        run: () => deleteWhere(db, table, "log_name", log)
+      });
+    });
+  });
+  [
+    "dcb_event",
+    "dcb_tag"
+  ].forEach(table => {
+    distinct(db, table, "log_name").filter(claimsLog).forEach(log => {
+      items.push({
+        label: table + ` (` + log + `)`,
+        count: countWhere(db, table, "log_name", log),
+        run: () => deleteWhere(db, table, "log_name", log)
+      });
+    });
+  });
+  distinct(db, "projection_checkpoint", "read_model").filter(rm => claimedComponents.includes(checkpointComponent(rm))).forEach(rm => {
+    items.push({
+      label: `projection_checkpoint (` + rm + `)`,
+      count: countWhere(db, "projection_checkpoint", "read_model", rm),
+      run: () => deleteWhere(db, "projection_checkpoint", "read_model", rm)
+    });
+  });
+  let claimedPrefixes;
+  if (typeof scope !== "object") {
+    switch (scope) {
+      case "Platform" :
+        claimedPrefixes = [];
+        break;
+      case "Domain" :
+      case "Everything" :
+        claimedPrefixes = ObjectStoreStorage_FileSystem$ReventlessLocal.topLevelPrefixes(root);
+        break;
+    }
+  } else {
+    claimedPrefixes = selectedPlugins.flatMap(p => p.stores.map(LocalObjectStore$ReventlessLocal.localPrefixFor));
+  }
+  claimedPrefixes.forEach(prefix => {
+    let count = ObjectStoreStorage_FileSystem$ReventlessLocal.keysUnder(root, prefix).length;
+    if (count > 0) {
+      items.push({
+        label: `objects/` + prefix + `/`,
+        count: count,
+        run: () => {
+          ObjectStoreStorage_FileSystem$ReventlessLocal.deleteUnder(root, prefix);
+        }
+      });
+      return;
+    }
+  });
+  let exit = 0;
+  if (typeof scope !== "object") {
+    switch (scope) {
+      case "Domain" :
+        break;
+      case "Platform" :
+      case "Everything" :
+        exit = 1;
+        break;
+    }
+  }
+  if (exit === 1) {
+    let count = ObjectStoreStorage_FileSystem$ReventlessLocal.offloadKeys(root).length;
+    if (count > 0) {
+      items.push({
+        label: "offload/",
+        count: count,
+        run: () => {
+          ObjectStoreStorage_FileSystem$ReventlessLocal.deleteOffloadAll(root);
+        }
+      });
+    }
+  }
+  let unattributed;
+  if (typeof scope !== "object") {
+    unattributed = [];
+  } else {
+    let claimedByAnyPlugin = plugins.flatMap(p => p.queryables.map(qdbTableName));
+    unattributed = qdbTables(db).filter(t => {
+      if (platformQdb.includes(t)) {
+        return false;
+      } else {
+        return !claimedByAnyPlugin.includes(t);
+      }
+    });
+  }
+  return {
+    scope: scope,
+    items: items,
+    unattributed: unattributed
+  };
+}
+
+function describe(p) {
+  console.log("");
+  console.log(`Reset scope: ` + scopeLabel(p.scope));
+  console.log("");
+  if (p.items.length === 0) {
+    console.log("  (nothing — this scope already reads empty)");
+  } else {
+    p.items.forEach(i => {
+      console.log(`  ` + i.count.toString().padStart(7, " ") + `  ` + i.label);
+    });
+  }
+  if (p.unattributed.length !== 0) {
+    console.log("");
+    console.log(`  Left alone — no connected plugin's structure claims them (widen the scope to include them):`);
+    p.unattributed.forEach(t => {
+      console.log(`    ` + t);
+    });
+  }
+  console.log("");
+}
+
+function execute(db, p) {
+  SqliteDriver$ReventlessLocal.transaction(db, () => {
+    p.items.forEach(i => i.run());
+  });
+}
+
+function scopeOptions(plugins) {
+  return [[
+      "domain",
+      "Domain"
+    ]].concat(plugins.map(p => [
+    p,
+    {
+      TAG: "OnePlugin",
+      _0: p
+    }
+  ])).concat([
+    [
+      "platform",
+      "Platform"
+    ],
+    [
+      "everything",
+      "Everything"
+    ]
+  ]);
+}
+
+function run(dbPath) {
+  let go = async () => {
+    let resolved;
+    if (dbPath !== undefined) {
+      resolved = dbPath;
+    } else {
+      let match = Backend$ReventlessLocal.fromEnv();
+      if (typeof match !== "object") {
+        console.log("Nothing to reset — REVENTLESS_LOCAL_BACKEND selects an in-memory store, which a restart already empties.");
+        resolved = undefined;
+      } else if (match.TAG === "Sqlite") {
+        let path = match.path;
+        if (path !== ":memory:") {
+          resolved = path;
+        } else {
+          console.log("Nothing to reset — REVENTLESS_LOCAL_BACKEND selects an in-memory store, which a restart already empties.");
+          resolved = undefined;
+        }
+      } else {
+        console.log("Nothing to reset here — the Postgres backend keeps its event logs off this machine. Reset it against the database.");
+        resolved = undefined;
+      }
+    }
+    if (resolved === undefined) {
+      return;
+    }
+    if (Nodefs.existsSync(resolved)) {
+      let root = Nodepath.dirname(resolved);
+      let db = SqliteDriver$ReventlessLocal.openDb(resolved);
+      let plugins = readPlugins(db, root).map(p => p.plugin);
+      let scope = await Seed_Prompt$ReventlessSeed.select("Reset scope:", scopeOptions(plugins), "SEED_RESET_SCOPE");
+      let plan = build(db, root, scope);
+      describe(plan);
+      if (total(plan) === 0) {
+        console.log("Nothing to do.");
+      } else {
+        let match$1 = Seed_Prompt$ReventlessSeed.envValue("SEED_RESET_CONFIRM");
+        let confirmed;
+        let exit = 0;
+        if (match$1 !== undefined) {
+          switch (match$1) {
+            case "1" :
+            case "yes" :
+              confirmed = true;
+              break;
+            default:
+              exit = 1;
+          }
+        } else {
+          exit = 1;
+        }
+        if (exit === 1) {
+          let answer = await Seed_Prompt$ReventlessSeed.ask(`Empty ` + total(plan).toString() + ` row(s)/object(s) in the "` + scopeLabel(plan.scope) + `" scope? [y/N]: `);
+          confirmed = answer.trim().toLowerCase() === "y";
+        }
+        if (confirmed) {
+          execute(db, plan);
+          console.log(`Reset complete — the "` + scopeLabel(plan.scope) + `" scope reads empty and is re-seedable.`);
+        } else {
+          console.log("Nothing was deleted.");
+        }
+      }
+      Seed_Prompt$ReventlessSeed.close();
+      return SqliteDriver$ReventlessLocal.close(db);
+    }
+    console.log(`Nothing to reset — no store at ` + resolved + `.`);
+  };
+  go();
+}
+
+export {
+  scopeLabel,
+  platformQueryables,
+  platformWritables,
+  qdbTableName,
+  aggregateLogName,
+  checkpointComponent,
+  tableExists,
+  strings,
+  qdbTables,
+  distinct,
+  countWhere,
+  countAll,
+  namesIn,
+  resolveStructure,
+  readPlugins,
+  total,
+  deleteWhere,
+  clearTable,
+  build,
+  describe,
+  execute,
+  scopeOptions,
+  run,
+}
+/* node:fs Not a pure module */

package/tests/adapter/BackendParityTest.res

@@ -205,6 +205,57 @@ describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderSqlite(scenario)
   })
 
+  testPromise("QueryDb: a descriptor carries the saved row and a rising seq under both", async () => {
+    let scenario = async () => {
+      module TestBus = LocalBus.Make()
+      module Storage = LocalQueryDbStorage.Make(TestBus)
+      let s = Storage.make(
+        ~name="parity-payload",
+        ~indexes=[],
+        ~api=(),
+        ~apiRole=(),
+        ~owner=None,
+        ~opts,
+      )
+      let ops = await s.operations->TestRunner.resolve
+
+      let descriptors = []
+      TestBus.subscribeToStateChanges("parity-payload", d => descriptors->Array.push(d))
+
+      let field = (d, key) => d->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
+      let item = (k, v) =>
+        JSON.Encode.object(
+          Dict.fromArray([("id", JSON.Encode.string(k)), ("v", JSON.Encode.string(v))]),
+        )
+      let stateAt = i => descriptors->Array.get(i)->Option.flatMap(d => field(d, "state"))
+
+      let _ = await ops.save("p1", item("p1", "one"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.save("p1", item("p1", "two"), ReventlessCore.QueryDb.Any, None)
+      let _ = await ops.delete("p1", None)
+
+      // The point of the payload: a subscriber can apply the row it was handed
+      // instead of spending a round-trip to fetch what the platform already had.
+      expect(stateAt(0))->toEqual(Some(item("p1", "one")))
+      expect(stateAt(1))->toEqual(Some(item("p1", "two")))
+      // A delete has no new row to carry.
+      expect(stateAt(2))->toEqual(None)
+
+      // seq only has to rise — it is monotonic, not consecutive, so a client can
+      // reject a stale payload but cannot count gaps.
+      let seqs =
+        descriptors->Array.filterMap(d =>
+          field(d, "seq")->Option.flatMap(JSON.Decode.string)->Option.flatMap(Float.fromString)
+        )
+      expect(seqs->Array.length)->toBe(3)
+      let rising =
+        seqs->Array.everyWithIndex((v, i) => i == 0 || v > seqs->Array.getUnsafe(i - 1))
+      expect(rising)->toBe(true)
+    }
+
+    await runUnderMemory(scenario)
+    await runUnderSqlite(scenario)
+  })
+
   testPromise("QueryDb: saveBatch reports Added then Updated for a repeated key under both", async () => {
     let scenario = async () => {
       module TestBus = LocalBus.Make()

package/tests/adapter/BackendParityTest.res.mjs

@@ -2,6 +2,8 @@
 
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 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_Float from "@rescript/runtime/lib/es6/Stdlib_Float.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
@@ -173,6 +175,48 @@ globalThis.describe("Backend parity (Memory vs Sqlite)", () => {
     await runUnderMemory(scenario);
     return await runUnderSqlite(scenario);
   });
+  globalThis.test("QueryDb: a descriptor carries the saved row and a rising seq under both", async () => {
+    let scenario = async () => {
+      let TestBus = LocalBus$ReventlessLocal.Make({});
+      let Storage = LocalQueryDbStorage$ReventlessLocal.Make(TestBus);
+      let s = Storage.make("parity-payload", [], undefined, undefined, undefined, undefined, undefined, opts);
+      let ops = await TestRunner$ReventlessLocal.resolve(s.operations);
+      let descriptors = [];
+      TestBus.subscribeToStateChanges("parity-payload", d => {
+        descriptors.push(d);
+      });
+      let field = (d, key) => Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(d), o => o[key]);
+      let item = (k, v) => Object.fromEntries([
+        [
+          "id",
+          k
+        ],
+        [
+          "v",
+          v
+        ]
+      ]);
+      let stateAt = i => Stdlib_Option.flatMap(descriptors[i], d => field(d, "state"));
+      await ops.save("p1", item("p1", "one"), "Any", undefined);
+      await ops.save("p1", item("p1", "two"), "Any", undefined);
+      await ops.delete("p1", undefined);
+      globalThis.expect(stateAt(0)).toEqual(item("p1", "one"));
+      globalThis.expect(stateAt(1)).toEqual(item("p1", "two"));
+      globalThis.expect(stateAt(2)).toEqual(undefined);
+      let seqs = Stdlib_Array.filterMap(descriptors, d => Stdlib_Option.flatMap(Stdlib_Option.flatMap(field(d, "seq"), Stdlib_JSON.Decode.string), Stdlib_Float.fromString));
+      globalThis.expect(seqs.length).toBe(3);
+      let rising = seqs.every((v, i) => {
+        if (i === 0) {
+          return true;
+        } else {
+          return v > seqs[i - 1 | 0];
+        }
+      });
+      globalThis.expect(rising).toBe(true);
+    };
+    await runUnderMemory(scenario);
+    return await runUnderSqlite(scenario);
+  });
   globalThis.test("QueryDb: saveBatch reports Added then Updated for a repeated key under both", async () => {
     let scenario = async () => {
       let TestBus = LocalBus$ReventlessLocal.Make({});

package/tests/adapter/GraphQL_SubscriptionResolversTest.res

@@ -77,8 +77,8 @@ describe("LocalGraphQL_SubscriptionResolvers", () => {
       let consumerPromise = startConsumer(iter, 1000)
       await yieldTick() // ensure listener is registered before publish
 
-      // Bus payload is now the change descriptor (Phase 8) matching the
-      // AWS StateTopic Lambda output shape: {changeKind, id, sortKeyValue?}.
+      // Bus payload is the change descriptor matching the AWS StateTopic Lambda
+      // output shape: {changeKind, id, sortKeyValue?, seq, state?}.
       let state = JSON.Encode.object(
         Dict.fromArray([
           ("id", JSON.Encode.string("prod-1")),
@@ -86,10 +86,11 @@ describe("LocalGraphQL_SubscriptionResolvers", () => {
           ("updatedAt", JSON.Encode.string("2026-05-19T12:00:00Z")),
         ]),
       )
-      let descriptor = LocalBus.makeStateChangeDescriptor(
+      let descriptor = LocalStateChangeDescriptor.make(
         ~changeKind="Updated",
         ~id="prod-1",
         ~state=Some(state),
+        ~seq=LocalStateChangeDescriptor.nextSequence(),
       )
       TestBus.publishStateChange(~name="Product", ~descriptor)
 
@@ -115,10 +116,11 @@ describe("LocalGraphQL_SubscriptionResolvers", () => {
       await yieldTick()
 
       // Publish for a DIFFERENT ReadModel — should NOT reach our topic.
-      let foreignDescriptor = LocalBus.makeStateChangeDescriptor(
+      let foreignDescriptor = LocalStateChangeDescriptor.make(
         ~changeKind="Updated",
         ~id="cat-1",
         ~state=Some(JSON.Encode.object(Dict.fromArray([("id", JSON.Encode.string("cat-1"))]))),
+        ~seq=LocalStateChangeDescriptor.nextSequence(),
       )
       TestBus.publishStateChange(~name="Category", ~descriptor=foreignDescriptor)