sqlite-zod-orm 3.6.2 → 3.7.1

package/dist/index.js

@@ -383,6 +383,34 @@ class QueryBuilder {
       clearInterval(timer);
     };
   }
+  each(callback, options = {}) {
+    const { interval = this.defaultPollInterval } = options;
+    const maxRows = this.executor(`SELECT MAX(id) as _max FROM ${this.tableName}`, [], true);
+    let lastMaxId = maxRows[0]?._max ?? 0;
+    let lastRevision = this.revisionGetter?.() ?? "0";
+    let stopped = false;
+    const poll = async () => {
+      if (stopped)
+        return;
+      const rev = this.revisionGetter?.() ?? "0";
+      if (rev !== lastRevision) {
+        lastRevision = rev;
+        const newRows = this.executor(`SELECT * FROM ${this.tableName} WHERE id > ? ORDER BY id ASC`, [lastMaxId], true);
+        for (const rawRow of newRows) {
+          if (stopped)
+            return;
+          await callback(rawRow);
+          lastMaxId = rawRow.id;
+        }
+      }
+      if (!stopped)
+        setTimeout(poll, interval);
+    };
+    setTimeout(poll, interval);
+    return () => {
+      stopped = true;
+    };
+  }
   buildFingerprintSQL() {
     const params = [];
     let sql = `SELECT COUNT(*) as _cnt, MAX(id) as _max FROM ${this.tableName}`;
@@ -4714,13 +4742,6 @@ class _Database {
         upsert: (conditions, data) => this.upsert(entityName, data, conditions),
         delete: (id) => this.delete(entityName, id),
         select: (...cols) => this._createQueryBuilder(entityName, cols),
-        on: (event, callback, options2) => {
-          if (event === "insert")
-            return this._createOnStream(entityName, callback, options2?.interval);
-          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
       };
       this[key] = accessor;
@@ -4770,122 +4791,6 @@ class _Database {
     const dataVersion = this.db.query("PRAGMA data_version").get()?.data_version ?? 0;
     return `${rev}:${dataVersion}`;
   }
-  _createOnStream(entityName, callback, intervalOverride) {
-    const interval = intervalOverride ?? this.pollInterval;
-    const maxRow = this.db.query(`SELECT MAX(id) as _max FROM "${entityName}"`).get();
-    let lastMaxId = maxRow?._max ?? 0;
-    let lastRevision = this._getRevision(entityName);
-    let stopped = false;
-    const poll = async () => {
-      if (stopped)
-        return;
-      const currentRevision = this._getRevision(entityName);
-      if (currentRevision !== lastRevision) {
-        lastRevision = currentRevision;
-        const newRows = this.db.query(`SELECT * FROM "${entityName}" WHERE id > ? ORDER BY id ASC`).all(lastMaxId);
-        for (const rawRow of newRows) {
-          if (stopped)
-            return;
-          const entity = this._attachMethods(entityName, transformFromStorage(rawRow, this.schemas[entityName]));
-          await callback(entity);
-          lastMaxId = rawRow.id;
-        }
-      }
-      if (!stopped)
-        setTimeout(poll, interval);
-    };
-    setTimeout(poll, interval);
-    return () => {
-      stopped = true;
-    };
-  }
-  _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();
-    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);
-    }
-    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 (watcher.stopped)
-        return;
-      const currentRevision = this._getRevision(entityName);
-      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;
-        for (const row of currentRows) {
-          currentMap.set(row.id, JSON.stringify(row));
-          currentEntities.set(row.id, row);
-        }
-        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);
-              }
-            }
-          }
-        }
-        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);
-              }
-            }
-          }
-        }
-        watcher.snapshot = currentMap;
-        watcher.snapshotEntities = currentEntities;
-      }
-      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 () => {
-      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) {
     const schema = this.schemas[entityName];
     const validatedData = asZodObject(schema).passthrough().parse(data);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.6.2",
+  "version": "3.7.1",
   "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,11 +59,6 @@ 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: (...args: any[]) => void | Promise<void>, options?: { interval?: number }) => {
-                    if (event === 'insert') return this._createOnStream(entityName, callback, options?.interval);
-                    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,
             };
             (this as any)[key] = accessor;
@@ -144,202 +139,6 @@ class _Database<Schemas extends SchemaMap> {
         return `${rev}:${dataVersion}`;
     }
 
-    // ===========================================================================
-    // Row Stream — .on(callback)
-    // ===========================================================================
-
-    /**
-     * Stream new rows one at a time, in insertion order.
-     *
-     * Uses a watermark (last seen id) to query only `WHERE id > ?`.
-     * Checks revision + data_version first to avoid unnecessary queries.
-     */
-    public _createOnStream(
-        entityName: string,
-        callback: (row: any) => void | Promise<void>,
-        intervalOverride?: number,
-    ): () => void {
-        const interval = intervalOverride ?? this.pollInterval;
-
-        // Initialize watermark to current max id (only emit NEW rows)
-        const maxRow = this.db.query(`SELECT MAX(id) as _max FROM "${entityName}"`).get() as any;
-        let lastMaxId: number = maxRow?._max ?? 0;
-        let lastRevision: string = this._getRevision(entityName);
-        let stopped = false;
-
-        // Self-scheduling async loop: guarantees strict ordering
-        // - Each callback (sync or async) completes before the next row is emitted
-        // - Next poll only starts after the current batch is fully processed
-        const poll = async () => {
-            if (stopped) return;
-
-            // Fast check: did anything change?
-            const currentRevision = this._getRevision(entityName);
-            if (currentRevision !== lastRevision) {
-                lastRevision = currentRevision;
-
-                // Fetch new rows since watermark
-                const newRows = this.db.query(
-                    `SELECT * FROM "${entityName}" WHERE id > ? ORDER BY id ASC`
-                ).all(lastMaxId) as any[];
-
-                for (const rawRow of newRows) {
-                    if (stopped) return; // bail if unsubscribed mid-batch
-                    const entity = this._attachMethods(
-                        entityName,
-                        transformFromStorage(rawRow, this.schemas[entityName]!)
-                    );
-                    await callback(entity); // await async callbacks
-                    lastMaxId = rawRow.id;
-                }
-            }
-
-            // Schedule next poll only after this one is done
-            if (!stopped) setTimeout(poll, interval);
-        };
-
-        // Start the loop
-        setTimeout(poll, interval);
-
-        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;
-    }>();
-
-    /**
-     * Get or create a shared table watcher. One SELECT * per change event,
-     * no matter how many update/delete listeners are registered.
-     */
-    private _getWatcher(entityName: string) {
-        if (this._watchers.has(entityName)) return this._watchers.get(entityName)!;
-
-        // Build initial snapshot
-        const allRows = this.db.query(`SELECT * FROM "${entityName}" ORDER BY id ASC`).all() as 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);
-        }
-
-        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 (watcher.stopped) return;
-
-            const currentRevision = this._getRevision(entityName);
-            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>();
-                const currentEntities = new Map<number, any>();
-                for (const row of currentRows) {
-                    currentMap.set(row.id, JSON.stringify(row));
-                    currentEntities.set(row.id, row);
-                }
-
-                // 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);
-                            }
-                        }
-                    }
-                }
-
-                // 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);
-                            }
-                        }
-                    }
-                }
-
-                watcher.snapshot = currentMap;
-                watcher.snapshotEntities = currentEntities;
-            }
-
-            if (!watcher.stopped) setTimeout(poll, interval);
-        };
-
-        setTimeout(poll, interval);
-        return watcher;
-    }
-
-    /**
-     * 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);
-            }
-        };
-    }
-
     // ===========================================================================
     // CRUD
     // ===========================================================================

package/src/query-builder.ts

@@ -540,6 +540,65 @@ export class QueryBuilder<T extends Record<string, any>> {
         };
     }
 
+    /**
+     * Stream new rows one at a time via a watermark (last seen id).
+     *
+     * Unlike `.subscribe()` (which gives you an array snapshot), `.each()`
+     * calls your callback once per new row, in insertion order. The SQL
+     * `WHERE id > watermark` is rebuilt each poll with the latest value,
+     * so it's always O(new_rows) — not O(table_size).
+     *
+     * ```ts
+     * const unsub = db.messages.select().each((msg) => {
+     *     console.log('New:', msg.text);
+     * });
+     * ```
+     *
+     * @param callback  Called once per new row. Async callbacks are awaited.
+     * @param options   `interval` in ms (default: pollInterval).
+     * @returns Unsubscribe function.
+     */
+    each(
+        callback: (row: T) => void | Promise<void>,
+        options: { interval?: number } = {},
+    ): () => void {
+        const { interval = this.defaultPollInterval } = options;
+
+        // Initialize watermark to current max id
+        const maxRows = this.executor(
+            `SELECT MAX(id) as _max FROM ${this.tableName}`, [], true
+        );
+        let lastMaxId: number = (maxRows[0] as any)?._max ?? 0;
+        let lastRevision = this.revisionGetter?.() ?? '0';
+        let stopped = false;
+
+        const poll = async () => {
+            if (stopped) return;
+
+            const rev = this.revisionGetter?.() ?? '0';
+            if (rev !== lastRevision) {
+                lastRevision = rev;
+
+                // Fetch only new rows since watermark — O(new_rows)
+                const newRows = this.executor(
+                    `SELECT * FROM ${this.tableName} WHERE id > ? ORDER BY id ASC`,
+                    [lastMaxId], true
+                );
+
+                for (const rawRow of newRows) {
+                    if (stopped) return;
+                    await callback(rawRow as unknown as T);
+                    lastMaxId = (rawRow as any).id;
+                }
+            }
+
+            if (!stopped) setTimeout(poll, interval);
+        };
+
+        setTimeout(poll, interval);
+        return () => { stopped = true; };
+    }
+
     /** Build a lightweight fingerprint query (COUNT + MAX(id)) that shares the same WHERE clause. */
     private buildFingerprintSQL(): { sql: string; params: any[] } {
         const params: any[] = [];

package/src/types.ts

@@ -149,21 +149,6 @@ export type NavEntityAccessor<
     upsert: (conditions?: Partial<z.infer<S[Table & keyof S]>>, data?: Partial<z.infer<S[Table & keyof S]>>) => NavEntity<S, R, Table>;
     delete: (id: number) => void;
     select: (...cols: (keyof z.infer<S[Table & keyof S]> & string)[]) => QueryBuilder<NavEntity<S, R, Table>>;
-    /**
-     * Listen for table events.
-     *
-     * `'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: '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];
 };
@@ -189,21 +174,6 @@ export type EntityAccessor<S extends z.ZodType<any>> = {
     upsert: (conditions?: Partial<InferSchema<S>>, data?: Partial<InferSchema<S>>) => AugmentedEntity<S>;
     delete: (id: number) => void;
     select: (...cols: (keyof InferSchema<S> & string)[]) => QueryBuilder<AugmentedEntity<S>>;
-    /**
-     * Listen for table events.
-     *
-     * `'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: '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;
 };