@reventlessdev/reventless-local 3.0.0-alpha.115 → 3.0.0-alpha.116

package/src/adapter/EventCollector/LocalEventCollectorChannel.res.mjs

@@ -39,7 +39,51 @@ function Make(Bus) {
   };
 }
 
+function MakeProjection(Bus) {
+  let make = (param, eventTopics, param$1) => {
+    let eventTopicResources = Object.values(eventTopics).flatMap(outputs => outputs.resources);
+    return {
+      parts: undefined,
+      resources: eventTopicResources,
+      enqueueEvent: Pulumi.output((param, param$1, param$2) => Promise.resolve()),
+      handleChannelEvent: handleEvents => Pulumi.output((json, _ctx) => Effect.map(handleEvents(Stream.fromIterable([json])), () => {}))
+    };
+  };
+  let connect = (name, channelSpecs, runtime, param) => {
+    Effect.runPromise(Effect.flatMap(Deferred.await(runtime.parts.handlerDeferred), handler => Effect.sync(() => Bus.registerEventCollectorHandler(name, handler))));
+    channelSpecs.forEach(param => {
+      Object.values(param.eventTopics).forEach(topicOutputs => {
+        topicOutputs.resources.forEach(resource => {
+          resource.name.apply(topicName => {
+            let drainEffect = Effect.scoped(Effect.flatMap(Bus.subscribeToEventStream(topicName), stream => Stream.runForEach(stream, msg => Effect.zipRight(Effect.promise(async () => {
+              let handler = await Effect.runPromise(Deferred.await(runtime.parts.handlerDeferred));
+              return await handler(msg.json, undefined);
+            }), msg.done_))));
+            Effect.runFork(drainEffect);
+            Effect.runPromise(runtime.parts.subscriptionLatch.open);
+          });
+        });
+      });
+    });
+    return [];
+  };
+  let Base = {
+    make: make,
+    connect: connect
+  };
+  let connect$1 = (name, channelSpecs, runtime, opts) => {
+    Effect.runPromise(Effect.flatMap(Deferred.await(runtime.parts.handlerDeferred), handler => Effect.sync(() => Bus.registerProjectionCatchupHandler(name, handler))));
+    return connect(name, channelSpecs, runtime, opts);
+  };
+  return {
+    Base: Base,
+    make: make,
+    connect: connect$1
+  };
+}
+
 export {
   Make,
+  MakeProjection,
 }
 /* effect/Effect Not a pure module */

package/src/adapter/EventLog/EventLogStorage_InMemory.res

@@ -12,6 +12,10 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
     ->Stm.commit
     ->Effect.runSync
 
+  // Keep-one snapshot per aggregate id. Node.js is single-threaded and snapshot
+  // writes are fire-and-forget upserts, so a plain dict suffices (no Stm).
+  let snapshots: dict<ReventlessCore.EventLog.snapshot> = Dict.make()
+
   let append: ReventlessCore.EventLog.append<string, JSON.t> = (seqNr, id, jsons) =>
     Stm.TRef.modify(eventsRef, events => {
       let existing = events->Dict.get(id)->Option.getOr([])
@@ -28,10 +32,17 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
 
   // The in-memory array is already resident; expose it as a stream for API uniformity.
   // The real performance gain from streaming comes from the DynamoDB adapter.
-  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
+  // Events are stored contiguously from seq 0, so the array index equals the
+  // sequence number and `fromSeq` is a plain slice offset.
+  let replayStream = (id, ~fromSeq=0) =>
     Stm.TRef.get(eventsRef)
     ->Stm.commit
-    ->Effect.map(events => events->Dict.get(id)->Option.getOr([]))
+    ->Effect.map(events =>
+      events
+      ->Dict.get(id)
+      ->Option.getOr([])
+      ->Array.filterWithIndex((_, i) => i >= fromSeq)
+    )
     ->Stream.fromEffect
     ->Stream.flatMap(arr => Stream.fromIterable(arr))
 
@@ -39,6 +50,14 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
   let replay: ReventlessCore.EventLog.replay<string, JSON.t> = id =>
     replayStream(id)->Stream.runCollect->Effect.runPromise
 
+  let latestSnapshot: ReventlessCore.EventLog.latestSnapshot<string> = async id =>
+    Ok(snapshots->Dict.get(id))
+
+  let writeSnapshot: ReventlessCore.EventLog.writeSnapshot<string> = async (id, snap) => {
+    snapshots->Dict.set(id, snap)
+    Ok()
+  }
+
   // Appends each stream item sequentially to storage.
   // Node.js is single-threaded so a plain ref is safe for the seqNr counter.
   let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) => {
@@ -76,6 +95,8 @@ let makeMemoryStorage = (~name as _name, ~opts as _) => {
         replay,
         replayStream,
         appendStream,
+        latestSnapshot,
+        writeSnapshot,
       }),
     },
   )

package/src/adapter/EventLog/EventLogStorage_InMemory.res.mjs

@@ -13,6 +13,7 @@ import * as EventLogStorage_Sqlite$ReventlessLocal from "./EventLogStorage_Sqlit
 
 function makeMemoryStorage(_name, param) {
   let eventsRef = Effect.runSync(STM.commit(TRef.make({})));
+  let snapshots = {};
   let append = (seqNr, id, jsons) => Effect.runPromise(STM.commit(TRef.modify(eventsRef, events => {
     let existing = Stdlib_Option.getOr(events[id], []);
     let currentCount = existing.length;
@@ -35,8 +36,22 @@ function makeMemoryStorage(_name, param) {
       ];
     }
   })));
-  let replayStream = id => Stream$1.flatMap(Stream$1.fromEffect(Effect.map(STM.commit(TRef.get(eventsRef)), events => Stdlib_Option.getOr(events[id], []))), arr => Stream$1.fromIterable(arr));
-  let replay = id => Effect.runPromise(Stream.runCollect(replayStream(id)));
+  let replayStream = (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    return Stream$1.flatMap(Stream$1.fromEffect(Effect.map(STM.commit(TRef.get(eventsRef)), events => Stdlib_Option.getOr(events[id], []).filter((param, i) => i >= fromSeq))), arr => Stream$1.fromIterable(arr));
+  };
+  let replay = id => Effect.runPromise(Stream.runCollect(replayStream(id, undefined)));
+  let latestSnapshot = async id => ({
+    TAG: "Ok",
+    _0: snapshots[id]
+  });
+  let writeSnapshot = async (id, snap) => {
+    snapshots[id] = snap;
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  };
   let appendStream = (startingSeqNr, id, stream) => {
     let seqNrRef = {
       contents: startingSeqNr
@@ -79,7 +94,9 @@ function makeMemoryStorage(_name, param) {
         append: append,
         replay: replay,
         replayStream: replayStream,
-        appendStream: appendStream
+        appendStream: appendStream,
+        latestSnapshot: latestSnapshot,
+        writeSnapshot: writeSnapshot
       })
     }
   ];

package/src/adapter/EventLog/EventLogStorage_Sqlite.res

@@ -16,10 +16,18 @@
 
 open ReventlessCore
 
-let ensureSchema = (db: SqliteDriver.t) =>
+let ensureSchema = (db: SqliteDriver.t) => {
   db->SqliteDriver.exec(
     "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))",
   )
+  // Keep-one aggregate-state snapshots (docs/plans/aggregate-snapshotting.md):
+  // one row per (log, aggregate), overwritten on every snapshot write. `state`
+  // is the JSON-encoded fold of events seq 0..seq_nr-1; `schema_hash` lets the
+  // consumer detect a state-schema drift and fall back to full replay.
+  db->SqliteDriver.exec(
+    "CREATE TABLE IF NOT EXISTS snapshot (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, state TEXT NOT NULL, schema_hash TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id))",
+  )
+}
 
 // Decodes the JSON column to a JSON.t. Returns JSON.Null on unparseable input
 // (should not happen for data we wrote ourselves).
@@ -53,15 +61,27 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
   let insertStmt = db->SqliteDriver.prepare(
     "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)",
   )
-  let countStmt = db->SqliteDriver.prepare(
-    "SELECT COUNT(*) AS c FROM event_log WHERE log_name=? AND aggregate_id=?",
+  // Expected next seq_nr for an aggregate. Events are always appended
+  // contiguously from seq 0 (the OCC check below forbids gaps), so
+  // `MAX(seq_nr)+1` equals the row count — but it reads the rightmost leaf of the
+  // (log_name, aggregate_id, seq_nr) PK index in O(log n) instead of `COUNT(*)`
+  // scanning every row for the aggregate. `COALESCE(…, -1)+1` yields 0 when empty.
+  let nextSeqStmt = db->SqliteDriver.prepare(
+    "SELECT COALESCE(MAX(seq_nr), -1) + 1 AS c FROM event_log WHERE log_name=? AND aggregate_id=?",
   )
   let selectByIdStmt = db->SqliteDriver.prepare(
-    "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? ORDER BY seq_nr ASC",
+    "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? AND seq_nr >= ? ORDER BY seq_nr ASC",
+  )
+  let lastRowidStmt = db->SqliteDriver.prepare("SELECT last_insert_rowid() AS r")
+  let upsertSnapshotStmt = db->SqliteDriver.prepare(
+    "INSERT OR REPLACE INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash) VALUES(?,?,?,?,?)",
+  )
+  let selectSnapshotStmt = db->SqliteDriver.prepare(
+    "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name=? AND aggregate_id=?",
   )
 
-  let currentCount = (id: string): int =>
-    switch countStmt->SqliteDriver.get([JSON.Encode.string(name), JSON.Encode.string(id)]) {
+  let expectedNextSeq = (id: string): int =>
+    switch nextSeqStmt->SqliteDriver.get([JSON.Encode.string(name), JSON.Encode.string(id)]) {
     | Some(row) =>
       switch row->Dict.get("c") {
       | Some(JSON.Number(n)) => Float.toInt(n)
@@ -70,10 +90,14 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
     | None => 0
     }
 
-  let append: EventLog.append<string, JSON.t> = async (seqNr, id, jsons) => {
+  // `track=false` for appendStream: bulk-replayed batches never flow through
+  // the EventTopic publish cycle, so they must not enter the projection pending
+  // set — an entry nobody resolves would pin the checkpoint low-watermark
+  // forever (see ProjectionCheckpoint.res).
+  let appendTracked = async (~track, seqNr, id, jsons: array<JSON.t>) => {
     try {
-      db->SqliteDriver.transaction(() => {
-        let existing = currentCount(id)
+      let lastRowid = db->SqliteDriver.transaction(() => {
+        let existing = expectedNextSeq(id)
         if seqNr != existing {
           throw(Failure("conflict"))
         }
@@ -85,7 +109,34 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
             JSON.Encode.string(JSON.stringify(json)),
           ])
         })
+        switch lastRowidStmt->SqliteDriver.get([]) {
+        | Some(row) =>
+          switch row->Dict.get("r") {
+          | Some(JSON.Number(n)) => Float.toInt(n)
+          | _ => 0
+          }
+        | None => 0
+        }
       })
+      // Register the committed batch as appended-but-not-yet-published for the
+      // projection checkpoint low-watermark; Platform's afterPublish hook
+      // resolves the msgIds once the publish cycle completes. A transaction's
+      // inserts get contiguous rowids ending at lastRowid.
+      if track && lastRowid > 0 {
+        let count = jsons->Array.length
+        ProjectionPending.trackAppended(
+          ~axis=ProjectionPending.Aggregate,
+          jsons
+          ->Array.mapWithIndex((json, i) =>
+            json
+            ->JSON.Decode.object
+            ->Option.flatMap(d => d->Dict.get("msgId"))
+            ->Option.flatMap(JSON.Decode.string)
+            ->Option.map(msgId => (msgId, lastRowid - count + 1 + i))
+          )
+          ->Array.filterMap(x => x),
+        )
+      }
       Ok()
     } catch {
     // The deliberate seq_nr check above throws Failure("conflict"); a lost race
@@ -104,9 +155,16 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
     }
   }
 
-  let replayArray = (id: string): array<JSON.t> =>
+  let append: EventLog.append<string, JSON.t> = (seqNr, id, jsons) =>
+    appendTracked(~track=true, seqNr, id, jsons)
+
+  let replayArray = (id: string, ~fromSeq=0): array<JSON.t> =>
     selectByIdStmt
-    ->SqliteDriver.all([JSON.Encode.string(name), JSON.Encode.string(id)])
+    ->SqliteDriver.all([
+      JSON.Encode.string(name),
+      JSON.Encode.string(id),
+      JSON.Encode.int(fromSeq),
+    ])
     ->Array.map(decodePayload)
 
   let replay: EventLog.replay<string, JSON.t> = async id => replayArray(id)
@@ -114,25 +172,73 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
   // node:sqlite's iterate() could back a lazy stream, but the current Stream
   // API only has array-based fromIterable. Small events, dev-only backend →
   // materialise via all() and wrap. Swap to a lazy adapter if it matters.
-  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
-    replayArray(id)->Stream.fromIterable
-
-  let appendStream: EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) => {
-    let seqNrRef = ref(startingSeqNr)
-    stream->Stream.runForEach(json => {
-      let currentSeq = seqNrRef.contents
-      Effect.promise(() => append(currentSeq, id, [json]))->Effect.flatMap(result =>
+  let replayStream = (id, ~fromSeq=?) => replayArray(id, ~fromSeq=?fromSeq)->Stream.fromIterable
+
+  let latestSnapshot: EventLog.latestSnapshot<string> = async id =>
+    try {
+      switch selectSnapshotStmt->SqliteDriver.get([
+        JSON.Encode.string(name),
+        JSON.Encode.string(id),
+      ]) {
+      | Some(row) =>
+        switch (row->Dict.get("seq_nr"), row->Dict.get("state"), row->Dict.get("schema_hash")) {
+        | (Some(JSON.Number(seq)), Some(JSON.String(stateStr)), Some(JSON.String(schemaHash))) =>
+          Ok(
+            Some({
+              EventLog.seqNr: Float.toInt(seq),
+              state: JSON.parseOrThrow(stateStr),
+              schemaHash,
+            }),
+          )
+        | _ => Error("snapshot row has unexpected shape")
+        }
+      | None => Ok(None)
+      }
+    } catch {
+    | exn =>
+      Error(
+        exn->JsExn.fromException->Option.flatMap(JsExn.message)->Option.getOr("snapshot read error"),
+      )
+    }
+
+  let writeSnapshot: EventLog.writeSnapshot<string> = async (id, snap) =>
+    try {
+      upsertSnapshotStmt->SqliteDriver.run([
+        JSON.Encode.string(name),
+        JSON.Encode.string(id),
+        JSON.Encode.int(snap.seqNr),
+        JSON.Encode.string(JSON.stringify(snap.state)),
+        JSON.Encode.string(snap.schemaHash),
+      ])
+      Ok()
+    } catch {
+    | exn =>
+      Error(
+        exn
+        ->JsExn.fromException
+        ->Option.flatMap(JsExn.message)
+        ->Option.getOr("snapshot write error"),
+      )
+    }
+
+  // Collect the stream and hand the whole batch to `append`, which inserts every
+  // event under one transaction with a single OCC check (vs the old per-element
+  // append: one transaction + one seq lookup per event over a bulk replay). This
+  // also makes the replay atomic — all events land or none do, rather than
+  // leaving a partial prefix committed if a later element hit a raced PK.
+  let appendStream: EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) =>
+    stream
+    ->Stream.runCollect
+    ->Effect.flatMap(jsons =>
+      Effect.promise(() => appendTracked(~track=false, startingSeqNr, id, jsons))->Effect.flatMap(result =>
         switch result {
-        | Ok() =>
-          seqNrRef := currentSeq + 1
-          Effect.succeed()
+        | Ok() => Effect.succeed()
         // appendStream's error channel is a string; map the typed append error.
         | Error(ReventlessCore.EventLog.Conflict) => Effect.fail("conflict")
         | Error(StorageFailure(msg)) => Effect.fail(msg)
         }
       )
-    })
-  }
+    )
 
   (
     name,
@@ -144,6 +250,8 @@ let makeStorage = (~db: SqliteDriver.t, ~name: string, ~opts as _) => {
         replay,
         replayStream,
         appendStream,
+        latestSnapshot,
+        writeSnapshot,
       }),
     },
   )

package/src/adapter/EventLog/EventLogStorage_Sqlite.res.mjs

@@ -1,15 +1,20 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+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_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
-import * as Stream from "effect/Stream";
+import * as Stream$1 from "effect/Stream";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 import * as SqliteDriver$ReventlessLocal from "../SqliteDriver.res.mjs";
+import * as ProjectionPending$ReventlessLocal from "../ProjectionPending.res.mjs";
 
 function ensureSchema(db) {
   SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS snapshot (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, state TEXT NOT NULL, schema_hash TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id))");
 }
 
 function decodePayload(row) {
@@ -28,7 +33,7 @@ function decodePayload(row) {
 }
 
 function countAll(db) {
-  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  ensureSchema(db);
   let row = SqliteDriver$ReventlessLocal.get(SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM event_log"), []);
   if (row === undefined) {
     return 0;
@@ -42,12 +47,15 @@ function countAll(db) {
 }
 
 function makeStorage(db, name, param) {
-  SqliteDriver$ReventlessLocal.exec(db, "CREATE TABLE IF NOT EXISTS event_log (log_name TEXT NOT NULL, aggregate_id TEXT NOT NULL, seq_nr INTEGER NOT NULL, payload TEXT NOT NULL, PRIMARY KEY (log_name, aggregate_id, seq_nr))");
+  ensureSchema(db);
   let insertStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT INTO event_log(log_name, aggregate_id, seq_nr, payload) VALUES(?,?,?,?)");
-  let countStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COUNT(*) AS c FROM event_log WHERE log_name=? AND aggregate_id=?");
-  let selectByIdStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? ORDER BY seq_nr ASC");
-  let currentCount = id => {
-    let row = SqliteDriver$ReventlessLocal.get(countStmt, [
+  let nextSeqStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT COALESCE(MAX(seq_nr), -1) + 1 AS c FROM event_log WHERE log_name=? AND aggregate_id=?");
+  let selectByIdStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT payload FROM event_log WHERE log_name=? AND aggregate_id=? AND seq_nr >= ? ORDER BY seq_nr ASC");
+  let lastRowidStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT last_insert_rowid() AS r");
+  let upsertSnapshotStmt = SqliteDriver$ReventlessLocal.prepare(db, "INSERT OR REPLACE INTO snapshot(log_name, aggregate_id, seq_nr, state, schema_hash) VALUES(?,?,?,?,?)");
+  let selectSnapshotStmt = SqliteDriver$ReventlessLocal.prepare(db, "SELECT seq_nr, state, schema_hash FROM snapshot WHERE log_name=? AND aggregate_id=?");
+  let expectedNextSeq = id => {
+    let row = SqliteDriver$ReventlessLocal.get(nextSeqStmt, [
       name,
       id
     ]);
@@ -61,10 +69,10 @@ function makeStorage(db, name, param) {
       return 0;
     }
   };
-  let append = async (seqNr, id, jsons) => {
+  let appendTracked = async (track, seqNr, id, jsons) => {
     try {
-      SqliteDriver$ReventlessLocal.transaction(db, () => {
-        let existing = currentCount(id);
+      let lastRowid = SqliteDriver$ReventlessLocal.transaction(db, () => {
+        let existing = expectedNextSeq(id);
         if (seqNr !== existing) {
           throw {
             RE_EXN_ID: "Failure",
@@ -78,7 +86,24 @@ function makeStorage(db, name, param) {
           seqNr + i | 0,
           JSON.stringify(json)
         ]));
+        let row = SqliteDriver$ReventlessLocal.get(lastRowidStmt, []);
+        if (row === undefined) {
+          return 0;
+        }
+        let match = row["r"];
+        if (typeof match === "number") {
+          return match | 0;
+        } else {
+          return 0;
+        }
       });
+      if (track && lastRowid > 0) {
+        let count = jsons.length;
+        ProjectionPending$ReventlessLocal.trackAppended("Aggregate", Stdlib_Array.filterMap(jsons.map((json, i) => Stdlib_Option.map(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d["msgId"]), Stdlib_JSON.Decode.string), msgId => [
+          msgId,
+          ((lastRowid - count | 0) + 1 | 0) + i | 0
+        ])), x => x));
+      }
       return {
         TAG: "Ok",
         _0: undefined
@@ -119,32 +144,87 @@ function makeStorage(db, name, param) {
       }
     }
   };
-  let replayArray = id => SqliteDriver$ReventlessLocal.all(selectByIdStmt, [
-    name,
-    id
-  ]).map(decodePayload);
-  let replay = replayArray;
-  let replayStream = id => Stream.fromIterable(replayArray(id));
-  let appendStream = (startingSeqNr, id, stream) => {
-    let seqNrRef = {
-      contents: startingSeqNr
-    };
-    return Stream.runForEach(stream, json => {
-      let currentSeq = seqNrRef.contents;
-      return Effect.flatMap(Effect.promise(() => append(currentSeq, id, [json])), result => {
-        if (result.TAG === "Ok") {
-          seqNrRef.contents = currentSeq + 1 | 0;
-          return Effect.succeed();
-        }
-        let msg = result._0;
-        if (typeof msg !== "object") {
-          return Effect.fail("conflict");
-        } else {
-          return Effect.fail(msg._0);
-        }
-      });
-    });
+  let append = (seqNr, id, jsons) => appendTracked(true, seqNr, id, jsons);
+  let replayArray = (id, fromSeqOpt) => {
+    let fromSeq = fromSeqOpt !== undefined ? fromSeqOpt : 0;
+    return SqliteDriver$ReventlessLocal.all(selectByIdStmt, [
+      name,
+      id,
+      fromSeq
+    ]).map(decodePayload);
+  };
+  let replay = async id => replayArray(id, undefined);
+  let replayStream = (id, fromSeq) => Stream$1.fromIterable(replayArray(id, fromSeq));
+  let latestSnapshot = async id => {
+    try {
+      let row = SqliteDriver$ReventlessLocal.get(selectSnapshotStmt, [
+        name,
+        id
+      ]);
+      if (row === undefined) {
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+      let match = row["seq_nr"];
+      let match$1 = row["state"];
+      let match$2 = row["schema_hash"];
+      if (typeof match === "number" && typeof match$1 === "string" && typeof match$2 === "string") {
+        return {
+          TAG: "Ok",
+          _0: {
+            seqNr: match | 0,
+            state: JSON.parse(match$1),
+            schemaHash: match$2
+          }
+        };
+      } else {
+        return {
+          TAG: "Error",
+          _0: "snapshot row has unexpected shape"
+        };
+      }
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "snapshot read error")
+      };
+    }
   };
+  let writeSnapshot = async (id, snap) => {
+    try {
+      SqliteDriver$ReventlessLocal.run(upsertSnapshotStmt, [
+        name,
+        id,
+        snap.seqNr,
+        JSON.stringify(snap.state),
+        snap.schemaHash
+      ]);
+      return {
+        TAG: "Ok",
+        _0: undefined
+      };
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "snapshot write error")
+      };
+    }
+  };
+  let appendStream = (startingSeqNr, id, stream) => Effect.flatMap(Stream.runCollect(stream), jsons => Effect.flatMap(Effect.promise(() => appendTracked(false, startingSeqNr, id, jsons)), result => {
+    if (result.TAG === "Ok") {
+      return Effect.succeed();
+    }
+    let msg = result._0;
+    if (typeof msg !== "object") {
+      return Effect.fail("conflict");
+    } else {
+      return Effect.fail(msg._0);
+    }
+  }));
   return [
     name,
     replay,
@@ -154,7 +234,9 @@ function makeStorage(db, name, param) {
         append: append,
         replay: replay,
         replayStream: replayStream,
-        appendStream: appendStream
+        appendStream: appendStream,
+        latestSnapshot: latestSnapshot,
+        writeSnapshot: writeSnapshot
       })
     }
   ];
@@ -180,4 +262,4 @@ export {
   makeStorage,
   Make,
 }
-/* Stdlib_JsExn Not a pure module */
+/* Stream Not a pure module */