sqlite-zod-orm 3.7.3 → 3.8.0

package/dist/index.js

@@ -360,26 +360,15 @@ class QueryBuilder {
   }
   subscribe(callback, options = {}) {
     const { interval = this.defaultPollInterval, immediate = true } = options;
-    const fingerprintSQL = this.buildFingerprintSQL();
-    let lastCount = null;
-    let lastMax = null;
-    let lastInMemoryRev = null;
+    let lastRevision = null;
     let stopped = false;
     const poll = async () => {
       if (stopped)
         return;
       try {
         const rev = this.revisionGetter?.() ?? "0";
-        const inMemoryChanged = rev !== lastInMemoryRev;
-        lastInMemoryRev = rev;
-        const fpRows = this.executor(fingerprintSQL.sql, fingerprintSQL.params, true);
-        const fpRow = fpRows[0];
-        const cnt = fpRow?._cnt ?? 0;
-        const max = fpRow?._max ?? 0;
-        const fpChanged = cnt !== lastCount || max !== lastMax;
-        lastCount = cnt;
-        lastMax = max;
-        if (inMemoryChanged || fpChanged) {
+        if (rev !== lastRevision) {
+          lastRevision = rev;
           const rows = this.all();
           await callback(rows);
         }
@@ -455,11 +444,6 @@ class QueryBuilder {
     }
     return { sql: "", params: [] };
   }
-  buildFingerprintSQL() {
-    const where = this.buildWhereClause();
-    const sql = `SELECT COUNT(*) as _cnt, MAX(id) as _max FROM ${this.tableName}${where.sql ? ` WHERE ${where.sql}` : ""}`;
-    return { sql, params: where.params };
-  }
   then(onfulfilled, onrejected) {
     try {
       const result = this.all();
@@ -4748,6 +4732,7 @@ class _Database {
     this.pollInterval = options.pollInterval ?? 500;
     this.relationships = options.relations ? parseRelationsConfig(options.relations, schemas) : [];
     this.initializeTables();
+    this.initializeChangeTracking();
     this.runMigrations();
     if (options.indexes)
       this.createIndexes(options.indexes);
@@ -4782,6 +4767,24 @@ class _Database {
       this.db.run(`CREATE TABLE IF NOT EXISTS ${entityName} (id INTEGER PRIMARY KEY AUTOINCREMENT, ${allCols}${allConstraints})`);
     }
   }
+  initializeChangeTracking() {
+    this.db.run(`CREATE TABLE IF NOT EXISTS _satidb_changes (
+            tbl TEXT PRIMARY KEY,
+            seq INTEGER NOT NULL DEFAULT 0
+        )`);
+    for (const entityName of Object.keys(this.schemas)) {
+      this.db.run(`INSERT OR IGNORE INTO _satidb_changes (tbl, seq) VALUES (?, 0)`, entityName);
+      for (const op2 of ["insert", "update", "delete"]) {
+        const triggerName = `_satidb_${entityName}_${op2}`;
+        const event = op2.toUpperCase();
+        this.db.run(`CREATE TRIGGER IF NOT EXISTS ${triggerName}
+                    AFTER ${event} ON ${entityName}
+                    BEGIN
+                        UPDATE _satidb_changes SET seq = seq + 1 WHERE tbl = '${entityName}';
+                    END`);
+      }
+    }
+  }
   runMigrations() {
     for (const [entityName, schema] of Object.entries(this.schemas)) {
       const existingColumns = this.db.query(`PRAGMA table_info(${entityName})`).all();
@@ -4809,8 +4812,9 @@ class _Database {
   }
   _getRevision(entityName) {
     const rev = this._revisions[entityName] ?? 0;
-    const dataVersion = this.db.query("PRAGMA data_version").get()?.data_version ?? 0;
-    return `${rev}:${dataVersion}`;
+    const row = this.db.query("SELECT seq FROM _satidb_changes WHERE tbl = ?").get(entityName);
+    const seq = row?.seq ?? 0;
+    return `${rev}:${seq}`;
   }
   insert(entityName, data) {
     const schema = this.schemas[entityName];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.7.3",
+  "version": "3.8.0",
   "description": "Type-safe SQLite ORM for Bun — Zod schemas, fluent queries, auto relationships, zero SQL",
   "type": "module",
   "main": "./dist/index.js",

package/src/database.ts

@@ -31,8 +31,8 @@ class _Database<Schemas extends SchemaMap> {
     private options: DatabaseOptions;
     private pollInterval: number;
 
-    /** In-memory revision counter per table — bumps on every write (insert/update/delete).
-     *  Used by QueryBuilder.subscribe() fingerprint to detect ALL changes with zero overhead. */
+    /** In-memory revision counter per table — same-process fast path.
+     *  Complements the trigger-based _satidb_changes table for cross-process detection. */
     private _revisions: Record<string, number> = {};
 
     constructor(dbFile: string, schemas: Schemas, options: DatabaseOptions = {}) {
@@ -44,6 +44,7 @@ class _Database<Schemas extends SchemaMap> {
         this.pollInterval = options.pollInterval ?? 500;
         this.relationships = options.relations ? parseRelationsConfig(options.relations, schemas) : [];
         this.initializeTables();
+        this.initializeChangeTracking();
         this.runMigrations();
         if (options.indexes) this.createIndexes(options.indexes);
 
@@ -89,6 +90,36 @@ class _Database<Schemas extends SchemaMap> {
         }
     }
 
+    /**
+     * Initialize per-table change tracking using triggers.
+     *
+     * Creates a `_satidb_changes` table with one row per user table and a monotonic `seq` counter.
+     * INSERT/UPDATE/DELETE triggers on each user table auto-increment the seq.
+     * This enables table-specific, cross-process change detection — no PRAGMA data_version needed.
+     */
+    private initializeChangeTracking(): void {
+        this.db.run(`CREATE TABLE IF NOT EXISTS _satidb_changes (
+            tbl TEXT PRIMARY KEY,
+            seq INTEGER NOT NULL DEFAULT 0
+        )`);
+
+        for (const entityName of Object.keys(this.schemas)) {
+            // Ensure a row exists for this table
+            this.db.run(`INSERT OR IGNORE INTO _satidb_changes (tbl, seq) VALUES (?, 0)`, entityName);
+
+            // Create triggers (idempotent via IF NOT EXISTS)
+            for (const op of ['insert', 'update', 'delete'] as const) {
+                const triggerName = `_satidb_${entityName}_${op}`;
+                const event = op.toUpperCase();
+                this.db.run(`CREATE TRIGGER IF NOT EXISTS ${triggerName}
+                    AFTER ${event} ON ${entityName}
+                    BEGIN
+                        UPDATE _satidb_changes SET seq = seq + 1 WHERE tbl = '${entityName}';
+                    END`);
+            }
+        }
+    }
+
     private runMigrations(): void {
         for (const [entityName, schema] of Object.entries(this.schemas)) {
             const existingColumns = this.db.query(`PRAGMA table_info(${entityName})`).all() as any[];
@@ -115,28 +146,27 @@ class _Database<Schemas extends SchemaMap> {
     }
 
     // ===========================================================================
-    // Revision Tracking (in-memory + cross-process)
+    // Revision Tracking (trigger-based + in-memory fast path)
     // ===========================================================================
 
-    /** Bump the revision counter for a table. Called on every write. */
+    /** Bump the in-memory revision counter. Called by our CRUD methods (same-process fast path). */
     private _bumpRevision(entityName: string): void {
         this._revisions[entityName] = (this._revisions[entityName] ?? 0) + 1;
     }
 
     /**
-     * Get a composite revision string for a table.
+     * Get the change sequence for a table.
      *
-     * Combines two signals:
-     *  - In-memory counter: catches writes from THIS process (our CRUD methods bump it)
-     *  - PRAGMA data_version: catches writes from OTHER processes (SQLite bumps it
-     *    whenever another connection commits, but NOT for the current connection)
+     * Reads from `_satidb_changes` — a per-table seq counter bumped by triggers
+     * on every INSERT/UPDATE/DELETE, regardless of which connection performed the write.
      *
-     * Together they detect ALL changes regardless of source, with zero disk overhead.
+     * Combined with the in-memory counter for instant same-process detection.
      */
     public _getRevision(entityName: string): string {
         const rev = this._revisions[entityName] ?? 0;
-        const dataVersion = (this.db.query('PRAGMA data_version').get() as any)?.data_version ?? 0;
-        return `${rev}:${dataVersion}`;
+        const row = this.db.query('SELECT seq FROM _satidb_changes WHERE tbl = ?').get(entityName) as any;
+        const seq = row?.seq ?? 0;
+        return `${rev}:${seq}`;
     }
 
     // ===========================================================================

package/src/query-builder.ts

@@ -505,51 +505,28 @@ export class QueryBuilder<T extends Record<string, any>> {
     ): () => void {
         const { interval = this.defaultPollInterval, immediate = true } = options;
 
-        // Build the fingerprint SQL (COUNT + MAX(id)) using the same WHERE
-        const fingerprintSQL = this.buildFingerprintSQL();
-        let lastCount: number | null = null;
-        let lastMax: number | null = null;
-        let lastInMemoryRev: string | null = null;
+        let lastRevision: string | null = null;
         let stopped = false;
 
         const poll = async () => {
             if (stopped) return;
             try {
-                // Two-signal change detection:
-                //   1. In-memory revision (table-specific) → catches same-process writes
-                //   2. COUNT+MAX fingerprint (table-specific) → catches cross-process inserts/deletes
-                //
-                // Note: cross-process UPDATEs that don't change count/max are only caught
-                // by PRAGMA data_version, which is database-wide. We accept this tradeoff
-                // to avoid re-querying on writes to OTHER tables.
+                // Single check: revision combines in-memory counter (same-process)
+                // + trigger-based seq from _satidb_changes (cross-process).
+                // Both are table-specific — no false positives from other tables.
                 const rev = this.revisionGetter?.() ?? '0';
 
-                // Fast path: in-memory revision changed → our CRUD wrote to this table
-                const inMemoryChanged = rev !== lastInMemoryRev;
-                lastInMemoryRev = rev;
-
-                // Check table-specific fingerprint (COUNT + MAX(id))
-                const fpRows = this.executor(fingerprintSQL.sql, fingerprintSQL.params, true);
-                const fpRow = fpRows[0] as any;
-                const cnt = fpRow?._cnt ?? 0;
-                const max = fpRow?._max ?? 0;
-                const fpChanged = cnt !== lastCount || max !== lastMax;
-                lastCount = cnt;
-                lastMax = max;
-
-                // Fire callback only if THIS table actually changed
-                if (inMemoryChanged || fpChanged) {
+                if (rev !== lastRevision) {
+                    lastRevision = rev;
                     const rows = this.all();
                     await callback(rows);
                 }
             } catch {
                 // Silently skip on error (table might be in transition)
             }
-            // Self-scheduling: next poll only after this one completes
             if (!stopped) setTimeout(poll, interval);
         };
 
-        // Immediate first execution
         if (immediate) {
             poll();
         } else {
@@ -668,12 +645,6 @@ export class QueryBuilder<T extends Record<string, any>> {
         return { sql: '', params: [] };
     }
 
-    /** Build a lightweight fingerprint query (COUNT + MAX(id)) that shares the same WHERE clause. */
-    private buildFingerprintSQL(): { sql: string; params: any[] } {
-        const where = this.buildWhereClause();
-        const sql = `SELECT COUNT(*) as _cnt, MAX(id) as _max FROM ${this.tableName}${where.sql ? ` WHERE ${where.sql}` : ''}`;
-        return { sql, params: where.params };
-    }
 
     // ---------- Thenable (async/await support) ----------