@nt-ai-lab/deterministic-agent-workflow-event-store 0.2.0 → 0.2.1

package/dist/platform/domain/sqlite-event-store.d.ts

@@ -1,20 +1,9 @@
-import { z } from 'zod';
+import type { StoredEvent } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import { type SqliteDatabase } from '../infra/external-clients/sqlite/sqlite-runtime';
-declare const passthroughEventSchema: z.ZodObject<{
-    type: z.ZodString;
-    at: z.ZodString;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    type: z.ZodString;
-    at: z.ZodString;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    type: z.ZodString;
-    at: z.ZodString;
-}, z.ZodTypeAny, "passthrough">>;
-type BaseEvent = z.infer<typeof passthroughEventSchema>;
 /** @riviere-role value-object */
 export type SqliteEventStore = {
-    readonly readEvents: (sessionId: string) => readonly BaseEvent[];
-    readonly appendEvents: (sessionId: string, events: readonly BaseEvent[]) => void;
+    readonly readEvents: (sessionId: string) => readonly StoredEvent[];
+    readonly appendEvents: (sessionId: string, events: readonly StoredEvent[]) => void;
     readonly sessionExists: (sessionId: string) => boolean;
     readonly hasSessionStarted: (sessionId: string) => boolean;
     readonly listSessions: () => readonly string[];
@@ -24,4 +13,3 @@ export type SqliteEventStore = {
 export declare function createStore(dbPath: string): SqliteEventStore;
 /** @riviere-role domain-service */
 export declare function resolveSessionId(store: SqliteEventStore, input: string): string;
-export {};

package/dist/platform/domain/sqlite-event-store.js

@@ -1,50 +1,47 @@
 import { z } from 'zod';
-import { WorkflowStateError } from '@nt-ai-lab/deterministic-agent-workflow-engine';
+import { stripEnvelopeKeys, WorkflowStateError, } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import { enableWalMode, openSqliteDatabase, } from '../infra/external-clients/sqlite/sqlite-runtime.js';
-const passthroughEventSchema = z.object({
-    type: z.string(),
-    at: z.string(),
-}).passthrough();
 const createTableSql = `
   CREATE TABLE IF NOT EXISTS events (
     seq INTEGER PRIMARY KEY AUTOINCREMENT,
     session_id TEXT NOT NULL,
     type TEXT NOT NULL,
     at TEXT NOT NULL,
+    state TEXT,
     payload TEXT NOT NULL
   )
 `;
-const rowWithPayloadSchema = z.array(z.object({ payload: z.string() }));
+const eventRowSchema = z.array(z.object({
+    type: z.string(),
+    at: z.string(),
+    state: z.string().nullable(),
+    payload: z.string(),
+}));
 const rowWithSessionIdSchema = z.array(z.object({ session_id: z.string() }));
 const countFieldSchema = z.union([z.number(), z.bigint(), z.string()]);
 const countRowSchema = z.object({ count: countFieldSchema });
+const tableInfoRowSchema = z.array(z.object({ name: z.string() }));
 /** @riviere-role domain-service */
 export function createStore(dbPath) {
     const db = openSqliteDatabase(dbPath);
     enableWalMode(db);
     db.exec(createTableSql);
+    ensureStateColumn(db);
     return {
         db,
         readEvents(sessionId) {
-            const rawRows = db.prepare('SELECT payload FROM events WHERE session_id = ? ORDER BY seq').all(sessionId);
-            const rows = rowWithPayloadSchema.parse(rawRows);
-            return rows.map((row, index) => {
-                const parsedPayload = tryParsePayload(row.payload, index);
-                const parsedEvent = passthroughEventSchema.safeParse(parsedPayload);
-                if (!parsedEvent.success) {
-                    throw new WorkflowStateError(`Invalid event at index ${index} for session ${sessionId}: ${parsedEvent.error.message}`);
-                }
-                return parsedEvent.data;
-            });
+            const rawRows = db.prepare('SELECT type, at, state, payload FROM events WHERE session_id = ? ORDER BY seq').all(sessionId);
+            const rows = eventRowSchema.parse(rawRows);
+            return rows.map((row, index) => buildStoredEvent(row, sessionId, index));
         },
         appendEvents(sessionId, events) {
             if (events.length === 0)
                 return;
-            const insert = db.prepare('INSERT INTO events (session_id, type, at, payload) VALUES (?, ?, ?, ?)');
+            const insert = db.prepare('INSERT INTO events (session_id, type, at, state, payload) VALUES (?, ?, ?, ?, ?)');
             db.exec('BEGIN IMMEDIATE');
             try {
                 for (const event of events) {
-                    insert.run(sessionId, event.type, event.at, JSON.stringify(event));
+                    insert.run(sessionId, event.envelope.type, event.envelope.at, event.envelope.state ?? null, JSON.stringify(event.payload));
                 }
                 db.exec('COMMIT');
             }
@@ -101,3 +98,33 @@ function tryParsePayload(payload, index) {
         throw new WorkflowStateError(`Cannot parse event payload at index ${index}: ${String(cause)}`);
     }
 }
+function ensureStateColumn(db) {
+    const rawColumns = db.prepare('PRAGMA table_info(events)').all();
+    const columns = tableInfoRowSchema.parse(rawColumns);
+    if (columns.some((column) => column.name === 'state'))
+        return;
+    db.exec('ALTER TABLE events ADD COLUMN state TEXT');
+}
+/**
+ * Dual-read adapter. Modern rows carry only domain fields in `payload` JSON
+ * (envelope in columns). Legacy rows have `type`/`at` duplicated inside the
+ * payload JSON and no `state` column value. Either way, normalize to
+ * `StoredEvent` with undefined state for legacy rows.
+ */
+function buildStoredEvent(row, sessionId, index) {
+    const parsedPayload = tryParsePayload(row.payload, index);
+    if (!isRecord(parsedPayload)) {
+        throw new WorkflowStateError(`Invalid event payload at index ${index} for session ${sessionId}: expected object`);
+    }
+    return {
+        envelope: {
+            type: row.type,
+            at: row.at,
+            state: row.state ?? undefined,
+        },
+        payload: stripEnvelopeKeys(parsedPayload),
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/deterministic-agent-workflow-event-store",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "private": false,
   "type": "module",
   "exports": {
@@ -11,8 +11,8 @@
     "dist"
   ],
   "dependencies": {
-    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.2.0",
-    "zod": "^3.25.76"
+    "zod": "^3.25.76",
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.2.1"
   },
   "publishConfig": {
     "access": "public"