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

package/dist/index.js

@@ -1487,12 +1487,13 @@ class EventWire {
   onSyncedCallback;
   reconnectTimeout;
   syncRequested = false;
-  viewSubscriptions = new Map;
-  viewSubCounter = 0;
-  pendingViewSubs = [];
-  constructor(baseUrl) {
+  querySubscriptions = new Map;
+  querySubCounter = 0;
+  enableEventSync;
+  constructor(baseUrl, options) {
     this.baseUrl = baseUrl;
     this.instanceId = ++eventWireInstanceCounter;
+    this.enableEventSync = options?.enableEventSync ?? true;
   }
   setScopeToken(scope, token) {
     if (token === null) {
@@ -1538,9 +1539,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.sendAllQuerySubscriptions();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -1616,9 +1619,13 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
-  subscribeQuery(descriptor, callback, scope) {
-    const subscriptionId = `qs_${++this.viewSubCounter}_${Date.now()}`;
-    this.viewSubscriptions.set(subscriptionId, callback);
+  subscribeQuery(descriptor, scope, callbacks) {
+    const subscriptionId = `qs_${this.instanceId}_${++this.querySubCounter}`;
+    this.querySubscriptions.set(subscriptionId, {
+      descriptor,
+      scope,
+      callbacks
+    });
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
         type: "subscribe-query",
@@ -1626,20 +1633,17 @@ class EventWire {
         descriptor,
         scope
       }));
-    } else {
-      this.pendingViewSubs.push({ subscriptionId, descriptor, scope });
     }
     return subscriptionId;
   }
   unsubscribeQuery(subscriptionId) {
-    this.viewSubscriptions.delete(subscriptionId);
+    this.querySubscriptions.delete(subscriptionId);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
         type: "unsubscribe-query",
         subscriptionId
       }));
     }
-    this.pendingViewSubs = this.pendingViewSubs.filter((s) => s.subscriptionId !== subscriptionId);
   }
   getState() {
     return this.state;
@@ -1672,10 +1676,17 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
-      case "query-data": {
-        const cb = this.viewSubscriptions.get(message.subscriptionId);
-        if (cb) {
-          cb(message.data);
+      case "query-snapshot": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
+        if (sub) {
+          sub.callbacks.onSnapshot(message.result ?? null);
+        }
+        break;
+      }
+      case "query-changes": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
+        if (sub && Array.isArray(message.changes)) {
+          sub.callbacks.onChanges(message.changes);
         }
         break;
       }
@@ -1703,18 +1714,17 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
-  flushPendingViewSubs() {
+  sendAllQuerySubscriptions() {
     if (!this.ws || this.state !== "connected")
       return;
-    for (const sub of this.pendingViewSubs) {
+    for (const [subscriptionId, sub] of this.querySubscriptions) {
       this.ws.send(JSON.stringify({
         type: "subscribe-query",
-        subscriptionId: sub.subscriptionId,
+        subscriptionId,
         descriptor: sub.descriptor,
         scope: sub.scope
       }));
     }
-    this.pendingViewSubs = [];
   }
   scheduleReconnect() {
     if (this.reconnectTimeout)
@@ -3541,6 +3551,48 @@ function deepMerge(target, source) {
 function isPlainObject(item) {
   return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
 }
+function murmurHash(key, seed = 0) {
+  let remainder, bytes, h1, h1b, c1, c2, k1, i;
+  remainder = key.length & 3;
+  bytes = key.length - remainder;
+  h1 = seed;
+  c1 = 3432918353;
+  c2 = 461845907;
+  i = 0;
+  while (i < bytes) {
+    k1 = key.charCodeAt(i) & 255 | (key.charCodeAt(++i) & 255) << 8 | (key.charCodeAt(++i) & 255) << 16 | (key.charCodeAt(++i) & 255) << 24;
+    ++i;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1b = (h1 & 65535) * 5 + (((h1 >>> 16) * 5 & 65535) << 16) & 4294967295;
+    h1 = (h1b & 65535) + 27492 + (((h1b >>> 16) + 58964 & 65535) << 16);
+  }
+  k1 = 0;
+  if (remainder >= 3) {
+    k1 ^= (key.charCodeAt(i + 2) & 255) << 16;
+  }
+  if (remainder >= 2) {
+    k1 ^= (key.charCodeAt(i + 1) & 255) << 8;
+  }
+  if (remainder >= 1) {
+    k1 ^= key.charCodeAt(i) & 255;
+    k1 = (k1 & 65535) * c1 + (((k1 >>> 16) * c1 & 65535) << 16) & 4294967295;
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = (k1 & 65535) * c2 + (((k1 >>> 16) * c2 & 65535) << 16) & 4294967295;
+    h1 ^= k1;
+  }
+  h1 ^= key.length;
+  h1 ^= h1 >>> 16;
+  h1 = (h1 & 65535) * 2246822507 + (((h1 >>> 16) * 2246822507 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 13;
+  h1 = (h1 & 65535) * 3266489909 + (((h1 >>> 16) * 3266489909 & 65535) << 16) & 4294967295;
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
 class ForkedStoreState extends StoreState {
   master;
   changedItems = new Map;
@@ -3689,12 +3741,19 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
+  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) {
     if (change.type === "set") {
       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,
@@ -3708,6 +3767,9 @@ class MasterStoreState extends StoreState {
     }
     if (change.type === "delete") {
       await transaction.remove(this.storeName, change.id);
+      if (transactionCache) {
+        transactionCache.delete(`${this.storeName}:${change.id}`);
+      }
       return {
         from: null,
         to: null,
@@ -3719,17 +3781,12 @@ class MasterStoreState extends StoreState {
       };
     }
     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,
@@ -3742,17 +3799,12 @@ class MasterStoreState extends StoreState {
       };
     }
     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,
@@ -3988,7 +4040,8 @@ class ObservableDataStorage {
   }
   handleStoreChange(storeName, events) {
     let hasChanges = false;
-    for (const query of this.trackedQueries.values()) {
+    const staleKeys = [];
+    for (const [key, query] of this.trackedQueries) {
       if (query.storeName !== storeName)
         continue;
       let currentResult = query.result;
@@ -4000,10 +4053,20 @@ class ObservableDataStorage {
           queryChanged = true;
         }
       }
-      if (queryChanged) {
-        query.result = currentResult;
+      if (!queryChanged)
+        continue;
+      if (query.options.limit !== undefined && query.result.length === query.options.limit && currentResult.length < query.options.limit) {
+        staleKeys.push(key);
         hasChanges = true;
+        continue;
       }
+      query.result = currentResult;
+      hasChanges = true;
+    }
+    for (const key of staleKeys) {
+      const query = this.trackedQueries.get(key);
+      this.source.getStore(query.storeName).unsubscribe(query.listener);
+      this.trackedQueries.delete(key);
     }
     if (hasChanges) {
       this.onChange();
@@ -4219,13 +4282,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);
   }
@@ -4281,244 +4337,135 @@ class Model {
     return s;
   }
 }
-class StreamingQueryCache {
-  stores = new Map;
-  views = [];
-  activeStreams = new Map;
-  pendingUnsubscribes = new Map;
-  streamScopes = new Map;
-  static UNSUBSCRIBE_DELAY_MS = 5000;
-  registerViews(views) {
-    this.views = views;
-    for (const view3 of views) {
-      if (!this.stores.has(view3.name)) {
-        this.stores.set(view3.name, new StreamingStore);
-      }
+function applyQueryChanges(result, changes) {
+  const next = [...result];
+  for (const change of changes) {
+    if (change.type === "delete") {
+      const idx = next.findIndex((it) => it._id === change.id);
+      if (idx !== -1)
+        next.splice(idx, 1);
     }
   }
-  getStore(viewName) {
-    if (!this.stores.has(viewName)) {
-      this.stores.set(viewName, new StreamingStore);
+  for (const change of changes) {
+    if (change.type === "set") {
+      const idx = next.findIndex((it) => it._id === change.id);
+      if (idx !== -1)
+        next.splice(idx, 1);
+      next.splice(change.index, 0, change.item);
     }
-    return this.stores.get(viewName);
-  }
-  hasData(viewName) {
-    const store = this.stores.get(viewName);
-    return store ? store.hasData() : false;
-  }
-  hasActiveStream(viewName) {
-    return this.activeStreams.has(viewName);
   }
-  registerStream(viewName, createStream) {
-    const pending = this.pendingUnsubscribes.get(viewName);
-    if (pending) {
-      clearTimeout(pending);
-      this.pendingUnsubscribes.delete(viewName);
-    }
-    const existing = this.activeStreams.get(viewName);
-    if (existing) {
-      existing.refCount++;
-      return {
-        unsubscribe: () => this.unregisterStream(viewName),
-        wasReused: true
+  return next;
+}
+class StreamingQueryCache {
+  entries = new Map;
+  static UNSUBSCRIBE_DELAY_MS = 5000;
+  entryKey(descriptor, scope) {
+    return `${scope ?? "default"}:${murmurHash(JSON.stringify(descriptor))}`;
+  }
+  subscribe(descriptor, scope, eventWire, onChange) {
+    const key = this.entryKey(descriptor, scope);
+    let entry = this.entries.get(key);
+    if (entry) {
+      if (entry.pendingUnsub) {
+        clearTimeout(entry.pendingUnsub);
+        entry.pendingUnsub = undefined;
+      }
+      entry.refCount++;
+    } else {
+      const newEntry = {
+        result: undefined,
+        hasResult: false,
+        listeners: new Set,
+        refCount: 1,
+        subscriptionId: ""
       };
+      newEntry.subscriptionId = eventWire.subscribeQuery(descriptor, scope, {
+        onSnapshot: (result) => {
+          newEntry.result = result;
+          newEntry.hasResult = true;
+          this.notify(newEntry);
+        },
+        onChanges: (changes) => {
+          if (!newEntry.hasResult || !Array.isArray(newEntry.result)) {
+            return;
+          }
+          newEntry.result = applyQueryChanges(newEntry.result, changes);
+          this.notify(newEntry);
+        }
+      });
+      this.entries.set(key, newEntry);
+      entry = newEntry;
     }
-    const streamConn = createStream();
-    this.activeStreams.set(viewName, {
-      unsubscribe: streamConn.unsubscribe,
-      refCount: 1
-    });
+    const subscribed = entry;
+    subscribed.listeners.add(onChange);
+    let active = true;
     return {
-      unsubscribe: () => this.unregisterStream(viewName),
-      wasReused: false
-    };
-  }
-  unregisterStream(viewName) {
-    const stream = this.activeStreams.get(viewName);
-    if (!stream)
-      return;
-    stream.refCount--;
-    if (stream.refCount <= 0) {
-      const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(viewName);
-        const current2 = this.activeStreams.get(viewName);
-        if (current2 && current2.refCount <= 0) {
-          current2.unsubscribe();
-          this.activeStreams.delete(viewName);
-          this.streamScopes.delete(viewName);
-        }
-      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
-      this.pendingUnsubscribes.set(viewName, timeout);
-    }
-  }
-  subscribeQuery(descriptor, eventWire, scope) {
-    const key = descriptor.element;
-    if (scope)
-      this.streamScopes.set(key, scope);
-    const { unsubscribe } = this.registerStream(key, () => {
-      const subId = eventWire.subscribeQuery(descriptor, (data) => {
-        this.setViewData(descriptor.element, data);
-      }, scope);
-      return { unsubscribe: () => eventWire.unsubscribeQuery(subId) };
-    });
-    return unsubscribe;
-  }
-  invalidateScope(scope) {
-    for (const [viewName, viewScope] of this.streamScopes) {
-      if (viewScope !== scope)
-        continue;
-      const pending = this.pendingUnsubscribes.get(viewName);
-      if (pending) {
-        clearTimeout(pending);
-        this.pendingUnsubscribes.delete(viewName);
+      read: () => ({
+        result: subscribed.result,
+        loading: !subscribed.hasResult
+      }),
+      unsubscribe: () => {
+        if (!active)
+          return;
+        active = false;
+        subscribed.listeners.delete(onChange);
+        subscribed.refCount--;
+        if (subscribed.refCount > 0)
+          return;
+        subscribed.pendingUnsub = setTimeout(() => {
+          subscribed.pendingUnsub = undefined;
+          if (subscribed.refCount > 0)
+            return;
+          eventWire.unsubscribeQuery(subscribed.subscriptionId);
+          this.entries.delete(key);
+        }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
       }
-      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();
-    }
-  }
-  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([]);
-    }
+    };
   }
-  async applyEvent(event3) {
-    for (const view3 of this.views) {
-      const handlers = view3.getHandlers();
-      const handler = handlers[event3.type];
-      if (!handler)
+  invalidateScope(scope, eventWire) {
+    const prefix = `${scope}:`;
+    for (const [key, entry] of this.entries) {
+      if (!key.startsWith(prefix))
         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);
-    }
-  }
-  clear() {
-    for (const stream of this.activeStreams.values()) {
-      stream.unsubscribe();
-    }
-    this.activeStreams.clear();
-    this.streamScopes.clear();
-    for (const timeout of this.pendingUnsubscribes.values()) {
-      clearTimeout(timeout);
-    }
-    this.pendingUnsubscribes.clear();
-    for (const store of this.stores.values()) {
-      store.clear();
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
+      this.entries.delete(key);
+      entry.result = undefined;
+      entry.hasResult = false;
+      this.notify(entry);
     }
   }
-}
-
-class StreamingStore {
-  data = new Map;
-  listeners = new Set;
-  initialized = false;
-  hasData() {
-    return this.initialized;
-  }
-  setAll(items) {
-    this.initialized = true;
-    this.data.clear();
-    for (const item of items) {
-      this.data.set(item._id, item);
-    }
-    this.notifyListeners(null);
-  }
-  set(id3, item) {
-    this.data.set(id3, item);
-    this.notifyListeners([{ type: "set", id: id3, item }]);
-  }
-  modify(id3, updates) {
-    const existing = this.data.get(id3);
-    if (existing) {
-      const updated = { ...existing, ...updates };
-      this.data.set(id3, updated);
-      this.notifyListeners([{ type: "set", id: id3, item: updated }]);
+  clear(eventWire) {
+    for (const entry of this.entries.values()) {
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
     }
+    this.entries.clear();
   }
-  remove(id3) {
-    if (this.data.delete(id3)) {
-      this.notifyListeners([{ type: "delete", id: id3, item: null }]);
-    }
-  }
-  clear() {
-    this.initialized = false;
-    this.data.clear();
-    this.notifyListeners(null);
-  }
-  find(options = {}) {
-    let results = Array.from(this.data.values());
-    if (options.where) {
-      results = results.filter((item) => checkItemMatchesWhere(item, options.where));
-    }
-    return applyOrderByAndLimit(results, options);
-  }
-  findOne(where) {
-    const results = this.find({ where });
-    return results[0];
-  }
-  subscribe(listener4) {
-    this.listeners.add(listener4);
-    return () => {
-      this.listeners.delete(listener4);
-    };
-  }
-  notifyListeners(events) {
-    for (const listener4 of this.listeners) {
-      listener4(events);
+  notify(entry) {
+    for (const listener4 of entry.listeners) {
+      try {
+        listener4();
+      } catch (err) {
+        console.error(`[Arc] Query cache listener error:`, err);
+      }
     }
   }
 }
 
 class StreamingEventPublisher {
-  cache;
   eventWire;
   views = [];
   subscribers = new Map;
-  constructor(cache, eventWire) {
-    this.cache = cache;
+  constructor(eventWire) {
     this.eventWire = eventWire;
   }
   registerViews(views) {
     this.views = views;
-    this.cache.registerViews(views);
   }
   async publish(event3) {
-    await this.cache.applyEvent(event3);
     await this.notifySubscribers(event3);
     this.eventWire.syncEvents([
       {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcote.tech/arc-adapter-db-sqlite",
-  "version": "0.7.14",
+  "version": "0.7.16",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,7 +20,7 @@
     "test": "bun test"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.7.14"
+    "@arcote.tech/arc": "^0.7.16"
   },
   "devDependencies": {
     "typescript": "^5.0.0"