@godspeedai/cognate-store-sqlite 0.1.2 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@godspeedai/cognate-store-sqlite",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Authoritative DurableStore on bun:sqlite (spec §13).",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,6 +22,6 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@godspeedai/cognate-events": "^0.1.2"
+    "@godspeedai/cognate-events": "^0.2.0"
   }
 }

package/src/index.ts

@@ -15,6 +15,7 @@ import type {
   OutboxSettlement,
   ProjectionCheckpoint,
   ProjectionCommit,
+  ProjectionSnapshot,
   Json,
 } from "@godspeedai/cognate-events";
 import { migrate } from "./schema.ts";
@@ -313,6 +314,15 @@ export function openSqliteStore(options: SqliteStoreOptions): DurableStore {
     db.query("DELETE FROM payloads WHERE event_id = ?").run(eventId);
     db.query("UPDATE events SET erasure_reason = ?, erasure_at = ? WHERE event_id = ?").run(reason, erasedAt, eventId);
 
+    // Idempotency results are derived copies: a stored result may quote the erased payload (the
+    // continuation-transition shape) or fold earlier events of the same stream (the updateState
+    // shape). Erasure tombstones such results so replay can never re-disclose the content.
+    db.query(
+      `UPDATE idempotency SET result = ?
+       WHERE EXISTS (SELECT 1 FROM json_each(idempotency.event_ids) je WHERE je.value = ?)
+          OR EXISTS (SELECT 1 FROM json_each(idempotency.event_ids) je JOIN events e ON e.event_id = je.value WHERE e.stream_id = ?)`,
+    ).run(JSON.stringify({ __erased: { reason, erasedAt } }), eventId, original.stream_id);
+
     ensureStream("$erasures");
     const sequence = streamVersionRow("$erasures") + 1;
     const tombstone = insertEventRow(
@@ -472,6 +482,29 @@ export function openSqliteStore(options: SqliteStoreOptions): DurableStore {
       return rows.map((row) => ({ key: row.key, value: JSON.parse(row.value) as Json }));
     },
 
+    async readProjectionSnapshot(name: string): Promise<ProjectionSnapshot> {
+      assertOpen();
+      // One statement, one snapshot: the checkpoint can never be ahead of the rows it is returned
+      // with, even with another process folding concurrently (DEBT-021).
+      const row = db
+        .query(
+          `SELECT
+             (SELECT json_object('name', name, 'version', version, 'position', position, 'status', status,
+                                 'error_position', error_position, 'error_event_id', error_event_id, 'error_message', error_message)
+              FROM projection_checkpoints WHERE name = ?1) AS checkpoint,
+             (SELECT json_group_array(json_object('key', ordered.key, 'value', json(ordered.value)))
+              FROM (SELECT key, value FROM projection_state WHERE name = ?1 ORDER BY key) AS ordered) AS rows`,
+        )
+        .get(name) as Row;
+      const checkpoint = row.checkpoint ? JSON.parse(row.checkpoint as string) : undefined;
+      return {
+        checkpoint: checkpoint
+          ? { ...checkpoint, error: checkpoint.error_event_id != null ? { position: checkpoint.error_position, eventId: checkpoint.error_event_id, message: checkpoint.error_message } : null }
+          : undefined,
+        rows: (JSON.parse(row.rows as string) as { key: string; value: Json }[]).map((entry) => ({ key: entry.key, value: entry.value })),
+      };
+    },
+
     async resetProjection(name: string): Promise<void> {
       assertOpen();
       const txn = db.transaction((n: string): void => {