@reventlessdev/reventless-local 3.0.0-alpha.200 → 3.0.0-alpha.202

package/src/adapter/ObjectStore/ObjectStoreStorage_FileSystem.res

@@ -0,0 +1,215 @@
+// On-disk arm of the local object store: bytes under the same directory the
+// SQLite database lives in, so uploads and offloaded payloads survive a restart
+// exactly like the events that reference them.
+//
+// The two were previously out of step: with `REVENTLESS_LOCAL_BACKEND=sqlite` an
+// event carrying an `Offloaded{store, key, …}` reference outlived the bytes it
+// pointed at, so a restart replayed events whose payloads had evaporated.
+//
+// Layout, rooted at the SQLite file's directory (`./.reventless` by convention):
+//
+//   objects/<key>            served-object bytes; the key's slashes become real
+//                            directories, so the tree mirrors the URL space the
+//                            dev server serves at /{prefix}/*
+//   object-meta/<key>.json   {"contentType": …} for that object
+//   offload/<key>            content-addressed offload payload (JSON text)
+//
+// Content type needs a sidecar because a file holds bytes and nothing else.
+// Keeping it in a PARALLEL tree rather than beside the object leaves `objects/`
+// an exact mirror of what is served — no `.json` companions to skip when
+// browsing, copying, or serving it directly.
+//
+// Every call is synchronous, matching the in-memory arm's signature: this is a
+// dev-only store on a local disk, and going async here would push promises
+// through the HTTP handlers and the offload hook for no benefit.
+
+let objectsDir = (~root) => NodePath.join([root, "objects"])
+let metaDir = (~root) => NodePath.join([root, "object-meta"])
+let offloadDir = (~root) => NodePath.join([root, "offload"])
+
+// A key becomes a path here, so it must not climb out of the root. Keys arrive
+// from URL paths as well as from content addressing, and `..` segments that were
+// inert as dict keys are not inert as path segments.
+let isSafeKey = (key: string): bool =>
+  key != "" &&
+  !(key->String.startsWith("/")) &&
+  key->String.split("/")->Array.every(seg => seg != "" && seg != "." && seg != "..")
+
+let writeUnder = (path: string, write: string => unit): unit => {
+  NodeFs.mkdirSync(NodePath.dirname(path), {recursive: true})
+  write(path)
+}
+
+// Drop directories the deleted object left behind, walking up until one still
+// holds something or `stopAt` is reached. S3 has no directories, so the empty
+// `<uuid>/` a released upload leaves is an artifact of the filesystem mapping,
+// not something the AWS path would have.
+let rec pruneEmptyDirs = (~stopAt: string, ~from: string): unit =>
+  if from != stopAt && from->String.length > stopAt->String.length {
+    let entries = try NodeFs.readdirSync(from, {withFileTypes: true}) catch {
+    | _ => []
+    }
+    if entries->Array.length == 0 {
+      try NodeFs.rmSync(from, {recursive: true, force: true}) catch {
+      | _ => ()
+      }
+      pruneEmptyDirs(~stopAt, ~from=NodePath.dirname(from))
+    }
+  }
+
+// ── Served objects ──────────────────────────────────────────────────────────
+
+let objectPath = (~root, ~key) => NodePath.join([objectsDir(~root), key])
+let metaPath = (~root, ~key) => NodePath.join([metaDir(~root), key ++ ".json"])
+
+let put = (~root: string, ~key: string, ~bytes: NodeBuffer.t, ~contentType: string): unit =>
+  if isSafeKey(key) {
+    writeUnder(objectPath(~root, ~key), path => NodeFs.writeFileSyncBuffer(path, bytes))
+    writeUnder(metaPath(~root, ~key), path =>
+      NodeFs.writeFileSync(
+        path,
+        Dict.fromArray([("contentType", JSON.Encode.string(contentType))])
+        ->JSON.Encode.object
+        ->JSON.stringify,
+      )
+    )
+  }
+
+let defaultContentType = "application/octet-stream"
+
+let readContentType = (~root, ~key): string =>
+  switch try Some(NodeFs.readFileSync(metaPath(~root, ~key))) catch {
+  | _ => None
+  } {
+  | Some(raw) =>
+    raw
+    ->JSON.parseOrThrow
+    ->JSON.Decode.object
+    ->Option.flatMap(d => d->Dict.get("contentType"))
+    ->Option.flatMap(JSON.Decode.string)
+    ->Option.getOr(defaultContentType)
+  | None => defaultContentType
+  }
+
+// The try covers the case where the key names a directory rather than a file
+// (`/uploads/<uuid>` when only `/uploads/<uuid>/logo.svg` was stored): reading it
+// throws EISDIR, and the answer the caller wants is the same 404 a missing key
+// gets.
+let get = (~root: string, ~key: string): option<(NodeBuffer.t, string)> =>
+  if !isSafeKey(key) {
+    None
+  } else {
+    switch try Some(NodeFs.readFileSyncBuffer(objectPath(~root, ~key))) catch {
+    | _ => None
+    } {
+    | Some(bytes) => Some((bytes, readContentType(~root, ~key)))
+    | None => None
+    }
+  }
+
+let removeFile = (path: string): unit =>
+  try NodeFs.unlinkSync(path) catch {
+  | _ => ()
+  }
+
+let delete = (~root: string, ~key: string): unit =>
+  if isSafeKey(key) {
+    let object = objectPath(~root, ~key)
+    let meta = metaPath(~root, ~key)
+    removeFile(object)
+    removeFile(meta)
+    pruneEmptyDirs(~stopAt=objectsDir(~root), ~from=NodePath.dirname(object))
+    pruneEmptyDirs(~stopAt=metaDir(~root), ~from=NodePath.dirname(meta))
+  }
+
+// ── Offload objects ─────────────────────────────────────────────────────────
+
+let offloadPath = (~root, ~key) => NodePath.join([offloadDir(~root), key])
+
+let putOffload = (~root: string, ~key: string, ~bytes: string): unit =>
+  if isSafeKey(key) {
+    writeUnder(offloadPath(~root, ~key), path => NodeFs.writeFileSync(path, bytes))
+  }
+
+let getOffload = (~root: string, ~key: string): option<string> =>
+  if !isSafeKey(key) {
+    None
+  } else {
+    try Some(NodeFs.readFileSync(offloadPath(~root, ~key))) catch {
+    | _ => None
+    }
+  }
+
+// ── Prefix-scoped inspection and removal ────────────────────────────────────
+//
+// What a scoped reset works in: an object belongs to the store whose key prefix
+// it sits under, so a wipe names a prefix and never a whole tree — the same
+// prefix-scoped delete the deployed reset issues against S3.
+
+let rec walkKeys = (~dir: string, ~prefix: string, ~into: array<string>): unit =>
+  switch try Some(NodeFs.readdirSync(dir, {withFileTypes: true})) catch {
+  | _ => None
+  } {
+  | None => ()
+  | Some(entries) =>
+    entries->Array.forEach(entry => {
+      let name = NodeFs.direntName(entry)
+      let key = prefix == "" ? name : `${prefix}/${name}`
+      if NodeFs.isDirectory(entry) {
+        walkKeys(~dir=NodePath.join([dir, name]), ~prefix=key, ~into)
+      } else {
+        into->Array.push(key)
+      }
+    })
+  }
+
+/** Every stored object key under `prefix` (the prefix itself included when it
+    names an object). An absent prefix is simply empty, not an error. */
+let keysUnder = (~root: string, ~prefix: string): array<string> => {
+  let into = []
+  walkKeys(~dir=NodePath.join([objectsDir(~root), prefix]), ~prefix, ~into)
+  into
+}
+
+/** Top-level key prefixes present in the store, one segment deep — what a plan
+    lists when it has to report objects no declared store claims. */
+let topLevelPrefixes = (~root: string): array<string> =>
+  switch try Some(NodeFs.readdirSync(objectsDir(~root), {withFileTypes: true})) catch {
+  | _ => None
+  } {
+  | None => []
+  | Some(entries) =>
+    entries->Array.filter(NodeFs.isDirectory)->Array.map(NodeFs.direntName)
+  }
+
+/** Deletes every object under `prefix`, returning how many were removed. Goes
+    through `delete` so the content-type sidecar and the emptied directories go
+    with each object. */
+let deleteUnder = (~root: string, ~prefix: string): int => {
+  let keys = keysUnder(~root, ~prefix)
+  keys->Array.forEach(key => delete(~root, ~key))
+  keys->Array.length
+}
+
+let offloadKeys = (~root: string): array<string> => {
+  let into = []
+  walkKeys(~dir=offloadDir(~root), ~prefix="", ~into)
+  into
+}
+
+let deleteOffloadAll = (~root: string): int => {
+  let keys = offloadKeys(~root)
+  try NodeFs.rmSync(offloadDir(~root), {recursive: true, force: true}) catch {
+  | _ => ()
+  }
+  keys->Array.length
+}
+
+// Removes the three trees, leaving the rest of the root (the database file, the
+// dev `users.yaml`) untouched.
+let reset = (~root: string): unit =>
+  [objectsDir(~root), metaDir(~root), offloadDir(~root)]->Array.forEach(dir =>
+    try NodeFs.rmSync(dir, {recursive: true, force: true}) catch {
+    | _ => ()
+    }
+  )

package/src/adapter/ObjectStore/ObjectStoreStorage_FileSystem.res.mjs

@@ -0,0 +1,286 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function objectsDir(root) {
+  return Nodepath.join(root, "objects");
+}
+
+function metaDir(root) {
+  return Nodepath.join(root, "object-meta");
+}
+
+function offloadDir(root) {
+  return Nodepath.join(root, "offload");
+}
+
+function isSafeKey(key) {
+  if (key !== "" && !key.startsWith("/")) {
+    return key.split("/").every(seg => {
+      if (seg !== "" && seg !== ".") {
+        return seg !== "..";
+      } else {
+        return false;
+      }
+    });
+  } else {
+    return false;
+  }
+}
+
+function writeUnder(path, write) {
+  Nodefs.mkdirSync(Nodepath.dirname(path), {
+    recursive: true
+  });
+  write(path);
+}
+
+function pruneEmptyDirs(stopAt, _from) {
+  while (true) {
+    let from = _from;
+    if (!(from !== stopAt && from.length > stopAt.length)) {
+      return;
+    }
+    let entries;
+    try {
+      entries = Nodefs.readdirSync(from, {
+        withFileTypes: true
+      });
+    } catch (exn) {
+      entries = [];
+    }
+    if (entries.length !== 0) {
+      return;
+    }
+    try {
+      Nodefs.rmSync(from, {
+        recursive: true,
+        force: true
+      });
+    } catch (exn$1) {
+      
+    }
+    _from = Nodepath.dirname(from);
+    continue;
+  };
+}
+
+function objectPath(root, key) {
+  return Nodepath.join(Nodepath.join(root, "objects"), key);
+}
+
+function metaPath(root, key) {
+  return Nodepath.join(Nodepath.join(root, "object-meta"), key + ".json");
+}
+
+function put(root, key, bytes, contentType) {
+  if (isSafeKey(key)) {
+    writeUnder(objectPath(root, key), path => {
+      Nodefs.writeFileSync(path, bytes);
+    });
+    return writeUnder(metaPath(root, key), path => {
+      Nodefs.writeFileSync(path, JSON.stringify(Object.fromEntries([[
+          "contentType",
+          contentType
+        ]])), "utf8");
+    });
+  }
+}
+
+let defaultContentType = "application/octet-stream";
+
+function readContentType(root, key) {
+  let raw;
+  try {
+    raw = Nodefs.readFileSync(metaPath(root, key), "utf8");
+  } catch (exn) {
+    raw = undefined;
+  }
+  if (raw !== undefined) {
+    return Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(raw)), d => d["contentType"]), Stdlib_JSON.Decode.string), defaultContentType);
+  } else {
+    return defaultContentType;
+  }
+}
+
+function get(root, key) {
+  if (!isSafeKey(key)) {
+    return;
+  }
+  let bytes;
+  try {
+    bytes = Nodefs.readFileSync(objectPath(root, key));
+  } catch (exn) {
+    bytes = undefined;
+  }
+  if (bytes !== undefined) {
+    return [
+      bytes,
+      readContentType(root, key)
+    ];
+  }
+}
+
+function removeFile(path) {
+  try {
+    Nodefs.unlinkSync(path);
+    return;
+  } catch (exn) {
+    return;
+  }
+}
+
+function $$delete(root, key) {
+  if (!isSafeKey(key)) {
+    return;
+  }
+  let object = objectPath(root, key);
+  let meta = metaPath(root, key);
+  removeFile(object);
+  removeFile(meta);
+  pruneEmptyDirs(Nodepath.join(root, "objects"), Nodepath.dirname(object));
+  pruneEmptyDirs(Nodepath.join(root, "object-meta"), Nodepath.dirname(meta));
+}
+
+function offloadPath(root, key) {
+  return Nodepath.join(Nodepath.join(root, "offload"), key);
+}
+
+function putOffload(root, key, bytes) {
+  if (isSafeKey(key)) {
+    return writeUnder(offloadPath(root, key), path => {
+      Nodefs.writeFileSync(path, bytes, "utf8");
+    });
+  }
+}
+
+function getOffload(root, key) {
+  if (!isSafeKey(key)) {
+    return;
+  }
+  try {
+    return Nodefs.readFileSync(offloadPath(root, key), "utf8");
+  } catch (exn) {
+    return;
+  }
+}
+
+function walkKeys(dir, prefix, into) {
+  let entries;
+  try {
+    entries = Nodefs.readdirSync(dir, {
+      withFileTypes: true
+    });
+  } catch (exn) {
+    entries = undefined;
+  }
+  if (entries !== undefined) {
+    entries.forEach(entry => {
+      let name = entry.name;
+      let key = prefix === "" ? name : prefix + `/` + name;
+      if (entry.isDirectory()) {
+        return walkKeys(Nodepath.join(dir, name), key, into);
+      } else {
+        into.push(key);
+        return;
+      }
+    });
+    return;
+  }
+}
+
+function keysUnder(root, prefix) {
+  let into = [];
+  walkKeys(Nodepath.join(Nodepath.join(root, "objects"), prefix), prefix, into);
+  return into;
+}
+
+function topLevelPrefixes(root) {
+  let entries;
+  try {
+    entries = Nodefs.readdirSync(Nodepath.join(root, "objects"), {
+      withFileTypes: true
+    });
+  } catch (exn) {
+    entries = undefined;
+  }
+  if (entries !== undefined) {
+    return entries.filter(prim => prim.isDirectory()).map(prim => prim.name);
+  } else {
+    return [];
+  }
+}
+
+function deleteUnder(root, prefix) {
+  let keys = keysUnder(root, prefix);
+  keys.forEach(key => $$delete(root, key));
+  return keys.length;
+}
+
+function offloadKeys(root) {
+  let into = [];
+  walkKeys(Nodepath.join(root, "offload"), "", into);
+  return into;
+}
+
+function deleteOffloadAll(root) {
+  let keys = offloadKeys(root);
+  try {
+    Nodefs.rmSync(Nodepath.join(root, "offload"), {
+      recursive: true,
+      force: true
+    });
+  } catch (exn) {
+    
+  }
+  return keys.length;
+}
+
+function reset(root) {
+  [
+    Nodepath.join(root, "objects"),
+    Nodepath.join(root, "object-meta"),
+    Nodepath.join(root, "offload")
+  ].forEach(dir => {
+    try {
+      Nodefs.rmSync(dir, {
+        recursive: true,
+        force: true
+      });
+      return;
+    } catch (exn) {
+      return;
+    }
+  });
+}
+
+export {
+  objectsDir,
+  metaDir,
+  offloadDir,
+  isSafeKey,
+  writeUnder,
+  pruneEmptyDirs,
+  objectPath,
+  metaPath,
+  put,
+  defaultContentType,
+  readContentType,
+  get,
+  removeFile,
+  $$delete,
+  offloadPath,
+  putOffload,
+  getOffload,
+  walkKeys,
+  keysUnder,
+  topLevelPrefixes,
+  deleteUnder,
+  offloadKeys,
+  deleteOffloadAll,
+  reset,
+}
+/* node:fs Not a pure module */

package/src/adapter/ObjectStore/ObjectStoreStorage_InMemory.res

@@ -0,0 +1,33 @@
+// In-process arm of the local object store: two dicts, wiped on restart.
+//
+// Selected when nothing durable is on local disk (Memory backend, a `:memory:`
+// SQLite, Postgres) — see BackendState.getObjectStoreRoot. Ephemeral by design:
+// with the events themselves gone on restart, the bytes they reference have
+// nothing to outlive.
+//
+// `get` returns a `(bytes, contentType)` pair rather than a record so that this
+// arm and ObjectStoreStorage_FileSystem share one signature without either
+// owning a type the other must import; LocalObjectStore names the pair.
+
+type stored = (NodeBuffer.t, string)
+
+let objects: dict<stored> = Dict.make()
+
+let put = (~key: string, ~bytes: NodeBuffer.t, ~contentType: string): unit =>
+  objects->Dict.set(key, (bytes, contentType))
+
+let get = (~key: string): option<stored> => objects->Dict.get(key)
+
+let delete = (~key: string): unit => objects->Dict.delete(key)
+
+// Offload payloads: a separate keyspace, for the reason LocalObjectStore gives.
+let offloadObjects: dict<string> = Dict.make()
+
+let putOffload = (~key: string, ~bytes: string): unit => offloadObjects->Dict.set(key, bytes)
+
+let getOffload = (~key: string): option<string> => offloadObjects->Dict.get(key)
+
+let reset = (): unit => {
+  objects->Dict.keysToArray->Array.forEach(k => objects->Dict.delete(k))
+  offloadObjects->Dict.keysToArray->Array.forEach(k => offloadObjects->Dict.delete(k))
+}

package/src/adapter/ObjectStore/ObjectStoreStorage_InMemory.res.mjs

@@ -0,0 +1,47 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+
+let objects = {};
+
+function put(key, bytes, contentType) {
+  objects[key] = [
+    bytes,
+    contentType
+  ];
+}
+
+function get(key) {
+  return objects[key];
+}
+
+function $$delete(key) {
+  Stdlib_Dict.$$delete(objects, key);
+}
+
+let offloadObjects = {};
+
+function putOffload(key, bytes) {
+  offloadObjects[key] = bytes;
+}
+
+function getOffload(key) {
+  return offloadObjects[key];
+}
+
+function reset() {
+  Object.keys(objects).forEach(k => Stdlib_Dict.$$delete(objects, k));
+  Object.keys(offloadObjects).forEach(k => Stdlib_Dict.$$delete(offloadObjects, k));
+}
+
+export {
+  objects,
+  put,
+  get,
+  $$delete,
+  offloadObjects,
+  putOffload,
+  getOffload,
+  reset,
+}
+/* No side effect */

package/src/adapter/QueryDb/LocalQueryDbStorage.res.mjs

@@ -39,4 +39,4 @@ function Make(Bus) {
 export {
   Make,
 }
-/* QueryDbStorage_Sqlite-ReventlessLocal Not a pure module */
+/* BackendState-ReventlessLocal Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res

@@ -193,19 +193,21 @@ module Make = (Bus: LocalBus.T) => {
 
     let publishSaved = (~changeKind: string, id: string, state: JSON.t) => {
       let subKey = getSubKey(state, subIdField)
-      let descriptor = LocalBus.makeStateChangeDescriptor(
+      let descriptor = LocalStateChangeDescriptor.make(
         ~changeKind,
         ~id=entityKeyFor(id, subKey),
         ~state=Some(state),
+        ~seq=LocalStateChangeDescriptor.nextSequence(),
       )
       Bus.publishStateChange(~name, ~descriptor)
     }
 
     let publishRemoved = (id: string, subKey: string) => {
-      let descriptor = LocalBus.makeStateChangeDescriptor(
+      let descriptor = LocalStateChangeDescriptor.make(
         ~changeKind="Removed",
         ~id=entityKeyFor(id, subKey),
         ~state=None,
+        ~seq=LocalStateChangeDescriptor.nextSequence(),
       )
       Bus.publishStateChange(~name, ~descriptor)
     }

package/src/adapter/QueryDb/QueryDbStorage_InMemory.res.mjs

@@ -6,7 +6,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stream from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
-import * as LocalBus$ReventlessLocal from "../LocalBus.res.mjs";
+import * as LocalStateChangeDescriptor$ReventlessLocal from "../LocalStateChangeDescriptor.res.mjs";
 
 function getSubKey(item, subIdField) {
   if (subIdField === undefined) {
@@ -167,11 +167,11 @@ function Make(Bus) {
     };
     let publishSaved = (changeKind, id, state) => {
       let subKey = getSubKey(state, subIdField);
-      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor(changeKind, entityKeyFor(id, subKey), state);
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make(changeKind, entityKeyFor(id, subKey), state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
       Bus.publishStateChange(name, descriptor);
     };
     let publishRemoved = (id, subKey) => {
-      let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
+      let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Removed", entityKeyFor(id, subKey), undefined, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
       Bus.publishStateChange(name, descriptor);
     };
     let save = async (id, state, _saveMode, ttl) => {

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res

@@ -257,10 +257,11 @@ let makeStorage = (
 
   let publishSaved = (~changeKind: string, id: string, state: JSON.t) => {
     let subKey = computeSubKey(state, subIdField)
-    let descriptor = LocalBus.makeStateChangeDescriptor(
+    let descriptor = LocalStateChangeDescriptor.make(
       ~changeKind,
       ~id=entityKeyFor(id, subKey),
       ~state=Some(state),
+      ~seq=LocalStateChangeDescriptor.nextSequence(),
     )
     bus.publishStateChange(~name, ~descriptor)
   }
@@ -278,10 +279,11 @@ let makeStorage = (
   }
 
   let publishRemoved = (id: string, subKey: string) => {
-    let descriptor = LocalBus.makeStateChangeDescriptor(
+    let descriptor = LocalStateChangeDescriptor.make(
       ~changeKind="Removed",
       ~id=entityKeyFor(id, subKey),
       ~state=None,
+      ~seq=LocalStateChangeDescriptor.nextSequence(),
     )
     bus.publishStateChange(~name, ~descriptor)
   }

package/src/adapter/QueryDb/QueryDbStorage_Sqlite.res.mjs

@@ -5,9 +5,9 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Stream from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
-import * as LocalBus$ReventlessLocal from "../LocalBus.res.mjs";
 import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
 import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
+import * as LocalStateChangeDescriptor$ReventlessLocal from "../LocalStateChangeDescriptor.res.mjs";
 
 function tableName(name) {
   return "qdb_" + name.replaceAll("-", "_");
@@ -194,7 +194,7 @@ function makeStorage(db, bus, name, indexes, subIdField) {
   };
   let publishSaved = (changeKind, id, state) => {
     let subKey = computeSubKey(state, subIdField);
-    let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor(changeKind, entityKeyFor(id, subKey), state);
+    let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make(changeKind, entityKeyFor(id, subKey), state, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
     bus.publishStateChange(name, descriptor);
   };
   let saveKind = (id, state) => {
@@ -209,7 +209,7 @@ function makeStorage(db, bus, name, indexes, subIdField) {
     }
   };
   let publishRemoved = (id, subKey) => {
-    let descriptor = LocalBus$ReventlessLocal.makeStateChangeDescriptor("Removed", entityKeyFor(id, subKey), undefined);
+    let descriptor = LocalStateChangeDescriptor$ReventlessLocal.make("Removed", entityKeyFor(id, subKey), undefined, LocalStateChangeDescriptor$ReventlessLocal.nextSequence());
     bus.publishStateChange(name, descriptor);
   };
   let rowKeysForPartition = id => SqliteDriver$ReventlessLocal.all(selectByPartitionStmt, [id]).map(row => {