sqlite-zod-orm 3.6.0 → 3.6.2

package/dist/index.js

@@ -4717,9 +4717,9 @@ class _Database {
         on: (event, callback, options2) => {
           if (event === "insert")
             return this._createOnStream(entityName, callback, options2?.interval);
-          if (event === "change")
-            return this._createChangeStream(entityName, callback, options2?.interval);
-          throw new Error(`Unknown event type: '${event}'. Supported: 'insert', 'change'`);
+          if (event === "update" || event === "delete")
+            return this._createChangeStream(entityName, event, callback, options2?.interval);
+          throw new Error(`Unknown event type: '${event}'. Supported: 'insert', 'update', 'delete'`);
         },
         _tableName: entityName
       };
@@ -4799,23 +4799,33 @@ class _Database {
       stopped = true;
     };
   }
-  _createChangeStream(entityName, callback, intervalOverride) {
-    const interval = intervalOverride ?? this.pollInterval;
+  _watchers = new Map;
+  _getWatcher(entityName) {
+    if (this._watchers.has(entityName))
+      return this._watchers.get(entityName);
     const allRows = this.db.query(`SELECT * FROM "${entityName}" ORDER BY id ASC`).all();
-    let snapshot = new Map;
-    let snapshotEntities = new Map;
+    const snapshot = new Map;
+    const snapshotEntities = new Map;
     for (const row of allRows) {
       snapshot.set(row.id, JSON.stringify(row));
       snapshotEntities.set(row.id, row);
     }
-    let lastRevision = this._getRevision(entityName);
-    let stopped = false;
+    const watcher = {
+      updateListeners: new Set,
+      deleteListeners: new Set,
+      snapshot,
+      snapshotEntities,
+      lastRevision: this._getRevision(entityName),
+      stopped: false
+    };
+    this._watchers.set(entityName, watcher);
+    const interval = this.pollInterval;
     const poll = async () => {
-      if (stopped)
+      if (watcher.stopped)
         return;
       const currentRevision = this._getRevision(entityName);
-      if (currentRevision !== lastRevision) {
-        lastRevision = currentRevision;
+      if (currentRevision !== watcher.lastRevision) {
+        watcher.lastRevision = currentRevision;
         const currentRows = this.db.query(`SELECT * FROM "${entityName}" ORDER BY id ASC`).all();
         const currentMap = new Map;
         const currentEntities = new Map;
@@ -4823,35 +4833,57 @@ class _Database {
           currentMap.set(row.id, JSON.stringify(row));
           currentEntities.set(row.id, row);
         }
-        for (const [id, json] of currentMap) {
-          if (stopped)
-            return;
-          if (!snapshot.has(id)) {
-            const entity = this._attachMethods(entityName, transformFromStorage(currentEntities.get(id), this.schemas[entityName]));
-            await callback({ type: "insert", row: entity });
-          } else if (snapshot.get(id) !== json) {
-            const entity = this._attachMethods(entityName, transformFromStorage(currentEntities.get(id), this.schemas[entityName]));
-            const oldEntity = this._attachMethods(entityName, transformFromStorage(snapshotEntities.get(id), this.schemas[entityName]));
-            await callback({ type: "update", row: entity, oldRow: oldEntity });
+        if (watcher.updateListeners.size > 0) {
+          for (const [id, json] of currentMap) {
+            if (watcher.stopped)
+              return;
+            if (watcher.snapshot.has(id) && watcher.snapshot.get(id) !== json) {
+              const entity = this._attachMethods(entityName, transformFromStorage(currentEntities.get(id), this.schemas[entityName]));
+              const oldEntity = this._attachMethods(entityName, transformFromStorage(watcher.snapshotEntities.get(id), this.schemas[entityName]));
+              for (const cb of watcher.updateListeners) {
+                await cb(entity, oldEntity);
+              }
+            }
           }
         }
-        for (const [id] of snapshot) {
-          if (stopped)
-            return;
-          if (!currentMap.has(id)) {
-            const oldEntity = this._attachMethods(entityName, transformFromStorage(snapshotEntities.get(id), this.schemas[entityName]));
-            await callback({ type: "delete", row: oldEntity, oldRow: oldEntity });
+        if (watcher.deleteListeners.size > 0) {
+          for (const [id] of watcher.snapshot) {
+            if (watcher.stopped)
+              return;
+            if (!currentMap.has(id)) {
+              const oldEntity = this._attachMethods(entityName, transformFromStorage(watcher.snapshotEntities.get(id), this.schemas[entityName]));
+              for (const cb of watcher.deleteListeners) {
+                await cb(oldEntity);
+              }
+            }
           }
         }
-        snapshot = currentMap;
-        snapshotEntities = currentEntities;
+        watcher.snapshot = currentMap;
+        watcher.snapshotEntities = currentEntities;
       }
-      if (!stopped)
+      if (!watcher.stopped)
         setTimeout(poll, interval);
     };
     setTimeout(poll, interval);
+    return watcher;
+  }
+  _createChangeStream(entityName, eventType, callback, _intervalOverride) {
+    const watcher = this._getWatcher(entityName);
+    if (eventType === "update") {
+      watcher.updateListeners.add(callback);
+    } else {
+      watcher.deleteListeners.add(callback);
+    }
     return () => {
-      stopped = true;
+      if (eventType === "update") {
+        watcher.updateListeners.delete(callback);
+      } else {
+        watcher.deleteListeners.delete(callback);
+      }
+      if (watcher.updateListeners.size === 0 && watcher.deleteListeners.size === 0) {
+        watcher.stopped = true;
+        this._watchers.delete(entityName);
+      }
     };
   }
   insert(entityName, data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.6.0",
+  "version": "3.6.2",
   "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

@@ -59,10 +59,10 @@ class _Database<Schemas extends SchemaMap> {
                 upsert: (conditions, data) => this.upsert(entityName, data, conditions),
                 delete: (id) => this.delete(entityName, id),
                 select: (...cols: string[]) => this._createQueryBuilder(entityName, cols),
-                on: (event: string, callback: (row: any) => void | Promise<void>, options?: { interval?: number }) => {
+                on: (event: string, callback: (...args: any[]) => void | Promise<void>, options?: { interval?: number }) => {
                     if (event === 'insert') return this._createOnStream(entityName, callback, options?.interval);
-                    if (event === 'change') return this._createChangeStream(entityName, callback, options?.interval);
-                    throw new Error(`Unknown event type: '${event}'. Supported: 'insert', 'change'`);
+                    if (event === 'update' || event === 'delete') return this._createChangeStream(entityName, event, callback, options?.interval);
+                    throw new Error(`Unknown event type: '${event}'. Supported: 'insert', 'update', 'delete'`);
                 },
                 _tableName: entityName,
             };
@@ -204,37 +204,54 @@ class _Database<Schemas extends SchemaMap> {
         return () => { stopped = true; };
     }
 
+    // ===========================================================================
+    // Table Watcher — shared snapshot-diff engine for update/delete events
+    // ===========================================================================
+
+    /** One watcher per table — shared by all update/delete listeners. */
+    private _watchers = new Map<string, {
+        updateListeners: Set<(row: any, oldRow: any) => void | Promise<void>>;
+        deleteListeners: Set<(row: any) => void | Promise<void>>;
+        snapshot: Map<number, string>;
+        snapshotEntities: Map<number, any>;
+        lastRevision: string;
+        stopped: boolean;
+    }>();
+
     /**
-     * Stream all mutations (insert / update / delete) as ChangeEvent objects.
-     *
-     * Maintains a full snapshot and diffs on each poll.
-     * Heavier than _createOnStream (which only tracks watermark), but catches all changes.
+     * Get or create a shared table watcher. One SELECT * per change event,
+     * no matter how many update/delete listeners are registered.
      */
-    public _createChangeStream(
-        entityName: string,
-        callback: (event: any) => void | Promise<void>,
-        intervalOverride?: number,
-    ): () => void {
-        const interval = intervalOverride ?? this.pollInterval;
+    private _getWatcher(entityName: string) {
+        if (this._watchers.has(entityName)) return this._watchers.get(entityName)!;
 
-        // Build initial snapshot: Map<id, serialized row>
+        // Build initial snapshot
         const allRows = this.db.query(`SELECT * FROM "${entityName}" ORDER BY id ASC`).all() as any[];
-        let snapshot = new Map<number, string>();
-        let snapshotEntities = new Map<number, any>();
+        const snapshot = new Map<number, string>();
+        const snapshotEntities = new Map<number, any>();
         for (const row of allRows) {
             snapshot.set(row.id, JSON.stringify(row));
             snapshotEntities.set(row.id, row);
         }
 
-        let lastRevision: string = this._getRevision(entityName);
-        let stopped = false;
+        const watcher = {
+            updateListeners: new Set<(row: any, oldRow: any) => void | Promise<void>>(),
+            deleteListeners: new Set<(row: any) => void | Promise<void>>(),
+            snapshot,
+            snapshotEntities,
+            lastRevision: this._getRevision(entityName),
+            stopped: false,
+        };
+        this._watchers.set(entityName, watcher);
 
+        // Single poll loop for all listeners on this table
+        const interval = this.pollInterval;
         const poll = async () => {
-            if (stopped) return;
+            if (watcher.stopped) return;
 
             const currentRevision = this._getRevision(entityName);
-            if (currentRevision !== lastRevision) {
-                lastRevision = currentRevision;
+            if (currentRevision !== watcher.lastRevision) {
+                watcher.lastRevision = currentRevision;
 
                 const currentRows = this.db.query(`SELECT * FROM "${entityName}" ORDER BY id ASC`).all() as any[];
                 const currentMap = new Map<number, string>();
@@ -244,52 +261,83 @@ class _Database<Schemas extends SchemaMap> {
                     currentEntities.set(row.id, row);
                 }
 
-                // Detect inserts and updates
-                for (const [id, json] of currentMap) {
-                    if (stopped) return;
-                    if (!snapshot.has(id)) {
-                        // INSERT
-                        const entity = this._attachMethods(
-                            entityName,
-                            transformFromStorage(currentEntities.get(id), this.schemas[entityName]!)
-                        );
-                        await callback({ type: 'insert', row: entity });
-                    } else if (snapshot.get(id) !== json) {
-                        // UPDATE
-                        const entity = this._attachMethods(
-                            entityName,
-                            transformFromStorage(currentEntities.get(id), this.schemas[entityName]!)
-                        );
-                        const oldEntity = this._attachMethods(
-                            entityName,
-                            transformFromStorage(snapshotEntities.get(id), this.schemas[entityName]!)
-                        );
-                        await callback({ type: 'update', row: entity, oldRow: oldEntity });
+                // Dispatch updates
+                if (watcher.updateListeners.size > 0) {
+                    for (const [id, json] of currentMap) {
+                        if (watcher.stopped) return;
+                        if (watcher.snapshot.has(id) && watcher.snapshot.get(id) !== json) {
+                            const entity = this._attachMethods(
+                                entityName,
+                                transformFromStorage(currentEntities.get(id), this.schemas[entityName]!)
+                            );
+                            const oldEntity = this._attachMethods(
+                                entityName,
+                                transformFromStorage(watcher.snapshotEntities.get(id), this.schemas[entityName]!)
+                            );
+                            for (const cb of watcher.updateListeners) {
+                                await cb(entity, oldEntity);
+                            }
+                        }
                     }
                 }
 
-                // Detect deletes
-                for (const [id] of snapshot) {
-                    if (stopped) return;
-                    if (!currentMap.has(id)) {
-                        const oldEntity = this._attachMethods(
-                            entityName,
-                            transformFromStorage(snapshotEntities.get(id), this.schemas[entityName]!)
-                        );
-                        await callback({ type: 'delete', row: oldEntity, oldRow: oldEntity });
+                // Dispatch deletes
+                if (watcher.deleteListeners.size > 0) {
+                    for (const [id] of watcher.snapshot) {
+                        if (watcher.stopped) return;
+                        if (!currentMap.has(id)) {
+                            const oldEntity = this._attachMethods(
+                                entityName,
+                                transformFromStorage(watcher.snapshotEntities.get(id), this.schemas[entityName]!)
+                            );
+                            for (const cb of watcher.deleteListeners) {
+                                await cb(oldEntity);
+                            }
+                        }
                     }
                 }
 
-                snapshot = currentMap;
-                snapshotEntities = currentEntities;
+                watcher.snapshot = currentMap;
+                watcher.snapshotEntities = currentEntities;
             }
 
-            if (!stopped) setTimeout(poll, interval);
+            if (!watcher.stopped) setTimeout(poll, interval);
         };
 
         setTimeout(poll, interval);
+        return watcher;
+    }
 
-        return () => { stopped = true; };
+    /**
+     * Register an update or delete listener on the shared table watcher.
+     * Returns an unsubscribe function that auto-stops the watcher when empty.
+     */
+    public _createChangeStream(
+        entityName: string,
+        eventType: 'update' | 'delete',
+        callback: (...args: any[]) => void | Promise<void>,
+        _intervalOverride?: number,  // reserved, uses global pollInterval
+    ): () => void {
+        const watcher = this._getWatcher(entityName);
+
+        if (eventType === 'update') {
+            watcher.updateListeners.add(callback as any);
+        } else {
+            watcher.deleteListeners.add(callback as any);
+        }
+
+        return () => {
+            if (eventType === 'update') {
+                watcher.updateListeners.delete(callback as any);
+            } else {
+                watcher.deleteListeners.delete(callback as any);
+            }
+            // Auto-stop watcher when all listeners removed
+            if (watcher.updateListeners.size === 0 && watcher.deleteListeners.size === 0) {
+                watcher.stopped = true;
+                this._watchers.delete(entityName);
+            }
+        };
     }
 
     // ===========================================================================

package/src/index.ts

@@ -7,7 +7,7 @@ export { Database } from './database';
 export type { DatabaseType } from './database';
 
 export type {
-    SchemaMap, DatabaseOptions, Relationship, ChangeEvent,
+    SchemaMap, DatabaseOptions, Relationship,
     EntityAccessor, TypedAccessors, AugmentedEntity, UpdateBuilder,
     InferSchema, EntityData, IndexDef,
     ProxyColumns, ColumnRef,

package/src/types.ts

@@ -45,12 +45,6 @@ export type Relationship = {
     foreignKey: string;
 };
 
-/** Change event emitted by .on('change', callback) */
-export type ChangeEvent<T = any> = {
-    type: 'insert' | 'update' | 'delete';
-    row: T;
-    oldRow?: T;   // present on 'update' and 'delete'
-};
 
 // =============================================================================
 // Type Helpers
@@ -158,15 +152,17 @@ export type NavEntityAccessor<
     /**
      * Listen for table events.
      *
-     * `'insert'` — streams new rows one at a time, in insertion order.
-     * `'change'` — streams all mutations: { type: 'insert'|'update'|'delete', row, oldRow? }.
+     * `'insert'` — streams new rows, one at a time.
+     * `'update'` — fires on row changes with (newRow, oldRow).
+     * `'delete'` — fires when a row is removed.
      *
      * Callbacks are awaited — strict ordering guaranteed even with async handlers.
      * @returns Unsubscribe function.
      */
     on: {
         (event: 'insert', callback: (row: NavEntity<S, R, Table>) => void | Promise<void>, options?: { interval?: number }): () => void;
-        (event: 'change', callback: (event: ChangeEvent<NavEntity<S, R, Table>>) => void | Promise<void>, options?: { interval?: number }): () => void;
+        (event: 'update', callback: (row: NavEntity<S, R, Table>, oldRow: NavEntity<S, R, Table>) => void | Promise<void>, options?: { interval?: number }): () => void;
+        (event: 'delete', callback: (row: NavEntity<S, R, Table>) => void | Promise<void>, options?: { interval?: number }): () => void;
     };
     _tableName: string;
     readonly _schema?: S[Table & keyof S];
@@ -196,15 +192,17 @@ export type EntityAccessor<S extends z.ZodType<any>> = {
     /**
      * Listen for table events.
      *
-     * `'insert'` — streams new rows one at a time, in insertion order.
-     * `'change'` — streams all mutations: { type: 'insert'|'update'|'delete', row, oldRow? }.
+     * `'insert'` — streams new rows, one at a time.
+     * `'update'` — fires on row changes with (newRow, oldRow).
+     * `'delete'` — fires when a row is removed.
      *
      * Callbacks are awaited — strict ordering guaranteed even with async handlers.
      * @returns Unsubscribe function.
      */
     on: {
         (event: 'insert', callback: (row: AugmentedEntity<S>) => void | Promise<void>, options?: { interval?: number }): () => void;
-        (event: 'change', callback: (event: ChangeEvent<AugmentedEntity<S>>) => void | Promise<void>, options?: { interval?: number }): () => void;
+        (event: 'update', callback: (row: AugmentedEntity<S>, oldRow: AugmentedEntity<S>) => void | Promise<void>, options?: { interval?: number }): () => void;
+        (event: 'delete', callback: (row: AugmentedEntity<S>) => void | Promise<void>, options?: { interval?: number }): () => void;
     };
     _tableName: string;
     readonly _schema?: S;