@arcote.tech/arc-adapter-db-sqlite-wasm 0.7.14 → 0.7.15

package/dist/index.js

@@ -1485,11 +1485,11 @@ class EventWire {
   reconnectTimeout;
   syncRequested = false;
   viewSubscriptions = new Map;
-  viewSubCounter = 0;
-  pendingViewSubs = [];
-  constructor(baseUrl) {
+  enableEventSync;
+  constructor(baseUrl, options) {
     this.baseUrl = baseUrl;
     this.instanceId = ++eventWireInstanceCounter;
+    this.enableEventSync = options?.enableEventSync ?? true;
   }
   setScopeToken(scope, token) {
     if (token === null) {
@@ -1535,9 +1535,11 @@ class EventWire {
         if (this.ws && this.ws.readyState === WebSocket.OPEN) {
           this.state = "connected";
           this.sendAllScopeTokens();
-          this.requestSync();
+          if (this.enableEventSync) {
+            this.requestSync();
+          }
           this.flushPendingEvents();
-          this.flushPendingViewSubs();
+          this.sendAllViewSubscriptions();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -1613,30 +1615,26 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
-  subscribeQuery(descriptor, callback, scope) {
-    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
-    this.viewSubscriptions.set(subscriptionId, callback);
+  subscribeView(element, scope, callbacks) {
+    const key = `${scope}:${element}`;
+    this.viewSubscriptions.set(key, callbacks);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
-        type: "subscribe-query",
-        subscriptionId,
-        descriptor,
+        type: "subscribe-view",
+        element,
         scope
       }));
-    } else {
-      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
     }
-    return subscriptionId;
   }
-  unsubscribeQuery(subscriptionId) {
-    this.viewSubscriptions.delete(subscriptionId);
+  unsubscribeView(element, scope) {
+    this.viewSubscriptions.delete(`${scope}:${element}`);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
-        type: "unsubscribe-query",
-        subscriptionId
+        type: "unsubscribe-view",
+        element,
+        scope
       }));
     }
-    this.pendingViewSubs = this.pendingViewSubs.filter((s) => s.subscriptionId !== subscriptionId);
   }
   getState() {
     return this.state;
@@ -1669,10 +1667,17 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
-      case "query-data": {
-        const cb = this.viewSubscriptions.get(message.subscriptionId);
-        if (cb) {
-          cb(message.data);
+      case "view-snapshot": {
+        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+        if (sub) {
+          sub.onSnapshot(message.items ?? []);
+        }
+        break;
+      }
+      case "view-changes": {
+        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+        if (sub && Array.isArray(message.changes)) {
+          sub.onChanges(message.changes);
         }
         break;
       }
@@ -1700,18 +1705,19 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
-  flushPendingViewSubs() {
+  sendAllViewSubscriptions() {
     if (!this.ws || this.state !== "connected")
       return;
-    for (const sub of this.pendingViewSubs) {
+    for (const key of this.viewSubscriptions.keys()) {
+      const sepIdx = key.indexOf(":");
+      const scope = key.slice(0, sepIdx);
+      const element = key.slice(sepIdx + 1);
       this.ws.send(JSON.stringify({
-        type: "subscribe-query",
-        subscriptionId: sub.subscriptionId,
-        descriptor: sub.descriptor,
-        scope: sub.scope
+        type: "subscribe-view",
+        element,
+        scope
       }));
     }
-    this.pendingViewSubs = [];
   }
   scheduleReconnect() {
     if (this.reconnectTimeout)
@@ -1733,12 +1739,19 @@ class LocalEventPublisher {
   views = [];
   syncCallback;
   subscribers = new Map;
+  viewChangesCallbacks = new Set;
   constructor(dataStorage) {
     this.dataStorage = dataStorage;
   }
   onPublish(callback) {
     this.syncCallback = callback;
   }
+  onViewChanges(callback) {
+    this.viewChangesCallbacks.add(callback);
+    return () => {
+      this.viewChangesCallbacks.delete(callback);
+    };
+  }
   registerViews(views) {
     this.views = views;
   }
@@ -1806,7 +1819,19 @@ class LocalEventPublisher {
     });
     const viewChanges = await this.collectViewChanges(event);
     allChanges.push(...viewChanges);
-    await this.dataStorage.commitChanges(allChanges);
+    const viewStoreNames = new Set(viewChanges.map((c) => c.store));
+    const committed = await this.dataStorage.commitChanges(allChanges, {
+      captureRowsFor: viewStoreNames
+    });
+    if (committed.length > 0 && this.viewChangesCallbacks.size > 0) {
+      for (const callback of this.viewChangesCallbacks) {
+        try {
+          callback(committed);
+        } catch (error) {
+          console.error(`[EventPublisher] onViewChanges callback error:`, error);
+        }
+      }
+    }
     await this.notifySubscribers(event);
     if (this.syncCallback) {
       this.syncCallback(event);
@@ -2446,8 +2471,9 @@ class ArcObject extends ArcAbstract {
   }
 }
 class DataStorage {
-  async commitChanges(changes) {
+  async commitChanges(changes, _options) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+    return [];
   }
 }
 
@@ -3686,12 +3712,23 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
-  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
+  async readExisting(transaction, id2, transactionCache) {
+    const cacheKey = `${this.storeName}:${id2}`;
+    if (transactionCache && transactionCache.has(cacheKey)) {
+      return transactionCache.get(cacheKey);
+    }
+    return transaction.find(this.storeName, { where: { _id: id2 } }).then((results) => results[0]);
+  }
+  async applyChangeAndReturnEvent(transaction, change, transactionCache, options) {
     if (change.type === "set") {
+      let existing;
+      if (options?.captureRows) {
+        existing = await this.readExisting(transaction, change.data._id, transactionCache);
+      }
       await transaction.set(this.storeName, change.data);
       const item = this.deserialize ? this.deserialize(change.data) : change.data;
       if (transactionCache) {
-        transactionCache.set(change.data._id, item);
+        transactionCache.set(`${this.storeName}:${change.data._id}`, item);
       }
       return {
         from: null,
@@ -3700,11 +3737,20 @@ class MasterStoreState extends StoreState {
           type: "set",
           item: change.data,
           id: change.data._id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: change.data
       };
     }
     if (change.type === "delete") {
+      let existing;
+      if (options?.captureRows) {
+        existing = await this.readExisting(transaction, change.id, transactionCache);
+      }
       await transaction.remove(this.storeName, change.id);
+      if (transactionCache) {
+        transactionCache.delete(`${this.storeName}:${change.id}`);
+      }
       return {
         from: null,
         to: null,
@@ -3712,21 +3758,18 @@ class MasterStoreState extends StoreState {
           type: "delete",
           item: null,
           id: change.id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: null
       };
     }
     if (change.type === "modify") {
-      let existing;
-      if (transactionCache && transactionCache.has(change.id)) {
-        existing = transactionCache.get(change.id);
-      } else {
-        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
-      }
+      const existing = await this.readExisting(transaction, change.id, transactionCache);
       const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...change.data };
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       if (transactionCache) {
-        transactionCache.set(change.id, item);
+        transactionCache.set(`${this.storeName}:${change.id}`, item);
       }
       return {
         from: null,
@@ -3735,21 +3778,18 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: updated
       };
     }
     if (change.type === "mutate") {
-      let existing;
-      if (transactionCache && transactionCache.has(change.id)) {
-        existing = transactionCache.get(change.id);
-      } else {
-        existing = await transaction.find(this.storeName, { where: { _id: change.id } }).then((results) => results[0]);
-      }
+      const existing = await this.readExisting(transaction, change.id, transactionCache);
       const updated = apply(existing || {}, change.patches);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       if (transactionCache) {
-        transactionCache.set(change.id, item);
+        transactionCache.set(`${this.storeName}:${change.id}`, item);
       }
       return {
         from: null,
@@ -3758,7 +3798,9 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        }
+        },
+        oldRow: existing ?? null,
+        newRow: updated
       };
     }
     throw new Error("Unknown change type");
@@ -3836,17 +3878,22 @@ class MasterDataStorage extends DataStorage {
   applySerializedChanges(changes) {
     return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
   }
-  async commitChanges(changes) {
+  async commitChanges(changes, options) {
     const transaction = await this.getReadWriteTransaction();
     const transactionCache = new Map;
     const eventsByStore = new Map;
+    const committed = [];
     for (const { store, changes: storeChanges } of changes) {
       const storeState = this.getStore(store);
       const storeEvents = [];
+      const capture = options?.captureRowsFor?.has(store) ?? false;
       for (const change of storeChanges) {
-        const { event: event3 } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache);
+        const { event: event3, oldRow, newRow } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache, { captureRows: capture });
         if (event3)
           storeEvents.push(event3);
+        if (capture) {
+          committed.push({ store, id: event3.id, oldRow, newRow });
+        }
       }
       if (storeEvents.length > 0) {
         eventsByStore.set(store, storeEvents);
@@ -3857,6 +3904,7 @@ class MasterDataStorage extends DataStorage {
       const storeState = this.getStore(store);
       storeState.notifyListenersPublic(events);
     }
+    return committed;
   }
   fork() {
     return new ForkedDataStorage(this);
@@ -3971,8 +4019,8 @@ class ObservableDataStorage {
   getReadWriteTransaction() {
     return this.source.getReadWriteTransaction();
   }
-  commitChanges(changes) {
-    return this.source.commitChanges(changes);
+  commitChanges(changes, options) {
+    return this.source.commitChanges(changes, options);
   }
   trackQuery(storeName, options, result, listener4) {
     const key = this.getQueryKey(storeName, options);
@@ -4216,13 +4264,6 @@ class ScopedModel {
     }
     return wire.query(viewName, options, this.getAuth());
   }
-  subscribeQuery(descriptor, callback) {
-    const wire = this.parent.getAdapters().eventWire;
-    if (!wire) {
-      throw new Error(`Cannot subscribe to query: no eventWire available.`);
-    }
-    return wire.subscribeQuery(descriptor, callback, this.scopeName);
-  }
   get query() {
     return buildContextAccessor(this.context, this.scopedAdapters, "queryContext", (descriptor) => descriptor);
   }
@@ -4278,120 +4319,107 @@ class Model {
     return s;
   }
 }
+var DEFAULT_SCOPE = "default";
+
 class StreamingQueryCache {
   stores = new Map;
   views = [];
   activeStreams = new Map;
   pendingUnsubscribes = new Map;
-  streamScopes = new Map;
   static UNSUBSCRIBE_DELAY_MS = 5000;
+  storeKey(viewName, scope) {
+    return `${scope ?? DEFAULT_SCOPE}:${viewName}`;
+  }
   registerViews(views) {
     this.views = views;
-    for (const view3 of views) {
-      if (!this.stores.has(view3.name)) {
-        this.stores.set(view3.name, new StreamingStore);
-      }
-    }
   }
-  getStore(viewName) {
-    if (!this.stores.has(viewName)) {
-      this.stores.set(viewName, new StreamingStore);
+  getStore(viewName, scope) {
+    const key = this.storeKey(viewName, scope);
+    if (!this.stores.has(key)) {
+      this.stores.set(key, new StreamingStore);
     }
-    return this.stores.get(viewName);
+    return this.stores.get(key);
   }
-  hasData(viewName) {
-    const store = this.stores.get(viewName);
+  hasData(viewName, scope) {
+    const store = this.stores.get(this.storeKey(viewName, scope));
     return store ? store.hasData() : false;
   }
-  hasActiveStream(viewName) {
-    return this.activeStreams.has(viewName);
-  }
-  registerStream(viewName, createStream) {
-    const pending = this.pendingUnsubscribes.get(viewName);
+  registerStream(key, createStream) {
+    const pending = this.pendingUnsubscribes.get(key);
     if (pending) {
       clearTimeout(pending);
-      this.pendingUnsubscribes.delete(viewName);
+      this.pendingUnsubscribes.delete(key);
     }
-    const existing = this.activeStreams.get(viewName);
+    const existing = this.activeStreams.get(key);
     if (existing) {
       existing.refCount++;
       return {
-        unsubscribe: () => this.unregisterStream(viewName),
+        unsubscribe: () => this.unregisterStream(key),
         wasReused: true
       };
     }
     const streamConn = createStream();
-    this.activeStreams.set(viewName, {
+    this.activeStreams.set(key, {
       unsubscribe: streamConn.unsubscribe,
       refCount: 1
     });
     return {
-      unsubscribe: () => this.unregisterStream(viewName),
+      unsubscribe: () => this.unregisterStream(key),
       wasReused: false
     };
   }
-  unregisterStream(viewName) {
-    const stream = this.activeStreams.get(viewName);
+  unregisterStream(key) {
+    const stream = this.activeStreams.get(key);
     if (!stream)
       return;
     stream.refCount--;
     if (stream.refCount <= 0) {
       const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(viewName);
-        const current2 = this.activeStreams.get(viewName);
+        this.pendingUnsubscribes.delete(key);
+        const current2 = this.activeStreams.get(key);
         if (current2 && current2.refCount <= 0) {
           current2.unsubscribe();
-          this.activeStreams.delete(viewName);
-          this.streamScopes.delete(viewName);
+          this.activeStreams.delete(key);
         }
       }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
-      this.pendingUnsubscribes.set(viewName, timeout);
+      this.pendingUnsubscribes.set(key, timeout);
     }
   }
-  subscribeQuery(descriptor, eventWire, scope) {
-    const key = descriptor.element;
-    if (scope)
-      this.streamScopes.set(key, scope);
+  subscribeView(viewName, eventWire, scope) {
+    const key = this.storeKey(viewName, scope);
     const { unsubscribe } = this.registerStream(key, () => {
-      const subId = eventWire.subscribeQuery(descriptor, (data) => {
-        this.setViewData(descriptor.element, data);
-      }, scope);
-      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
+      const store = this.stores.get(key) ?? new StreamingStore;
+      this.stores.set(key, store);
+      eventWire.subscribeView(viewName, scope ?? DEFAULT_SCOPE, {
+        onSnapshot: (items) => store.setAll(items),
+        onChanges: (changes) => store.applyChanges(changes)
+      });
+      return {
+        unsubscribe: () => eventWire.unsubscribeView(viewName, scope ?? DEFAULT_SCOPE)
+      };
     });
     return unsubscribe;
   }
   invalidateScope(scope) {
-    for (const [viewName, viewScope] of this.streamScopes) {
-      if (viewScope !== scope)
+    const prefix = `${scope}:`;
+    for (const [key, timeout] of this.pendingUnsubscribes) {
+      if (!key.startsWith(prefix))
         continue;
-      const pending = this.pendingUnsubscribes.get(viewName);
-      if (pending) {
-        clearTimeout(pending);
-        this.pendingUnsubscribes.delete(viewName);
-      }
-      const stream = this.activeStreams.get(viewName);
-      if (stream) {
-        try {
-          stream.unsubscribe();
-        } catch {}
-        this.activeStreams.delete(viewName);
-      }
-      this.streamScopes.delete(viewName);
-      const store = this.stores.get(viewName);
-      if (store)
-        store.clear();
+      clearTimeout(timeout);
+      this.pendingUnsubscribes.delete(key);
     }
-  }
-  setViewData(viewName, data) {
-    const store = this.stores.get(viewName);
-    if (!store)
-      return;
-    if (Array.isArray(data)) {
-      store.setAll(data);
-    } else if (data && typeof data === "object" && "_id" in data) {
-      store.setAll([data]);
-    } else {
-      store.setAll([]);
+    for (const [key, stream] of this.activeStreams) {
+      if (!key.startsWith(prefix))
+        continue;
+      try {
+        stream.unsubscribe();
+      } catch {}
+      this.activeStreams.delete(key);
+    }
+    for (const [key, store] of this.stores) {
+      if (!key.startsWith(prefix))
+        continue;
+      store.clear();
     }
   }
   async applyEvent(event3) {
@@ -4400,28 +4428,30 @@ class StreamingQueryCache {
       const handler = handlers[event3.type];
       if (!handler)
         continue;
-      const store = this.stores.get(view3.name);
-      if (!store)
-        continue;
-      const ctx = {
-        set: async (id3, data) => {
-          store.set(String(id3), { _id: String(id3), ...data });
-        },
-        modify: async (id3, data) => {
-          store.modify(String(id3), data);
-        },
-        remove: async (id3) => {
-          store.remove(String(id3));
-        },
-        find: async (options) => {
-          return store.find(options);
-        },
-        findOne: async (where) => {
-          return store.findOne(where);
-        },
-        $auth: {}
-      };
-      await handler(ctx, event3);
+      const suffix = `:${view3.name}`;
+      for (const [key, store] of this.stores) {
+        if (!key.endsWith(suffix))
+          continue;
+        const ctx = {
+          set: async (id3, data) => {
+            store.set(String(id3), { _id: String(id3), ...data });
+          },
+          modify: async (id3, data) => {
+            store.modify(String(id3), data);
+          },
+          remove: async (id3) => {
+            store.remove(String(id3));
+          },
+          find: async (options) => {
+            return store.find(options);
+          },
+          findOne: async (where) => {
+            return store.findOne(where);
+          },
+          $auth: {}
+        };
+        await handler(ctx, event3);
+      }
     }
   }
   clear() {
@@ -4429,7 +4459,6 @@ class StreamingQueryCache {
       stream.unsubscribe();
     }
     this.activeStreams.clear();
-    this.streamScopes.clear();
     for (const timeout of this.pendingUnsubscribes.values()) {
       clearTimeout(timeout);
     }
@@ -4455,6 +4484,18 @@ class StreamingStore {
     }
     this.notifyListeners(null);
   }
+  applyChanges(events) {
+    if (events.length === 0)
+      return;
+    for (const event3 of events) {
+      if (event3.type === "set" && event3.item) {
+        this.data.set(event3.id, event3.item);
+      } else if (event3.type === "delete") {
+        this.data.delete(event3.id);
+      }
+    }
+    this.notifyListeners(events);
+  }
   set(id3, item) {
     this.data.set(id3, item);
     this.notifyListeners([{ type: "set", id: id3, item }]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite-wasm",
-  "version": "0.7.14",
+  "version": "0.7.15",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -39,7 +39,7 @@
     "dev": "bun build ./src/index.ts ./src/worker.ts --outdir ./dist --target browser --format esm --watch"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.7.14",
+    "@arcote.tech/arc": "^0.7.15",
     "@sqlite.org/sqlite-wasm": "^3.46.0-build1"
   },
   "devDependencies": {