sqlite-zod-orm 3.6.0 → 3.6.1

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,7 +4799,7 @@ class _Database {
       stopped = true;
     };
   }
-  _createChangeStream(entityName, callback, intervalOverride) {
+  _createChangeStream(entityName, eventType, callback, intervalOverride) {
     const interval = intervalOverride ?? this.pollInterval;
     const allRows = this.db.query(`SELECT * FROM "${entityName}" ORDER BY id ASC`).all();
     let snapshot = new Map;
@@ -4823,24 +4823,24 @@ 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 (eventType === "update") {
+          for (const [id, json] of currentMap) {
+            if (stopped)
+              return;
+            if (snapshot.has(id) && 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(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 });
+        } else if (eventType === "delete") {
+          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(oldEntity);
+            }
           }
         }
         snapshot = currentMap;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlite-zod-orm",
-  "version": "3.6.0",
+  "version": "3.6.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,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,
             };
@@ -205,14 +205,18 @@ class _Database<Schemas extends SchemaMap> {
     }
 
     /**
-     * Stream all mutations (insert / update / delete) as ChangeEvent objects.
+     * Stream specific mutations (update or delete) with natural callback signatures.
      *
      * Maintains a full snapshot and diffs on each poll.
-     * Heavier than _createOnStream (which only tracks watermark), but catches all changes.
+     * Only fires for the subscribed event type.
+     *
+     * - 'update': callback(row, oldRow)
+     * - 'delete': callback(row)
      */
     public _createChangeStream(
         entityName: string,
-        callback: (event: any) => void | Promise<void>,
+        eventType: 'update' | 'delete',
+        callback: (...args: any[]) => void | Promise<void>,
         intervalOverride?: number,
     ): () => void {
         const interval = intervalOverride ?? this.pollInterval;
@@ -244,39 +248,33 @@ 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 });
+                if (eventType === 'update') {
+                    // Detect updates: existing rows whose JSON changed
+                    for (const [id, json] of currentMap) {
+                        if (stopped) return;
+                        if (snapshot.has(id) && 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(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 });
+                } else if (eventType === 'delete') {
+                    // Detect deletes: rows in snapshot but not in current
+                    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(oldEntity);
+                        }
                     }
                 }
 

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;