@arcote.tech/arc-adapter-db-postgres 0.7.15 → 0.7.17

package/dist/index.js

@@ -1470,6 +1470,42 @@ class AuthAdapter {
     this.scopes.clear();
   }
 }
+var DEFAULT_TIMEOUT_MS = 8000;
+var provider = null;
+var latestSync = null;
+var syncSeq = 0;
+function triggerModuleSync(scope, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  if (!provider) {
+    latestSync = Promise.resolve();
+    return latestSync;
+  }
+  const seq = ++syncSeq;
+  const run = (async () => {
+    try {
+      await provider(scope);
+    } catch (err) {
+      console.warn("[arc] module sync failed during setToken:", err);
+    }
+  })();
+  const guarded = new Promise((resolve) => {
+    let settled = false;
+    const done = () => {
+      if (settled)
+        return;
+      settled = true;
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      console.warn(`[arc] module sync did not complete within ${timeoutMs}ms; proceeding anyway.`);
+      done();
+    }, timeoutMs);
+    timer?.unref?.();
+    run.then(done, done).finally(() => clearTimeout(timer));
+  });
+  if (seq === syncSeq)
+    latestSync = guarded;
+  return guarded;
+}
 var eventWireInstanceCounter = 0;
 
 class EventWire {
@@ -1484,7 +1520,8 @@ class EventWire {
   onSyncedCallback;
   reconnectTimeout;
   syncRequested = false;
-  viewSubscriptions = new Map;
+  querySubscriptions = new Map;
+  querySubCounter = 0;
   enableEventSync;
   constructor(baseUrl, options) {
     this.baseUrl = baseUrl;
@@ -1539,7 +1576,7 @@ class EventWire {
             this.requestSync();
           }
           this.flushPendingEvents();
-          this.sendAllViewSubscriptions();
+          this.sendAllQuerySubscriptions();
         } else {
           console.log(`[EventWire] onopen called but ws is not OPEN, readyState:`, this.ws?.readyState);
         }
@@ -1615,24 +1652,29 @@ class EventWire {
   onSynced(callback) {
     this.onSyncedCallback = callback;
   }
-  subscribeView(element, scope, callbacks) {
-    const key = `${scope}:${element}`;
-    this.viewSubscriptions.set(key, callbacks);
+  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-view",
-        element,
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor,
         scope
       }));
     }
+    return subscriptionId;
   }
-  unsubscribeView(element, scope) {
-    this.viewSubscriptions.delete(`${scope}:${element}`);
+  unsubscribeQuery(subscriptionId) {
+    this.querySubscriptions.delete(subscriptionId);
     if (this.state === "connected" && this.ws) {
       this.ws.send(JSON.stringify({
-        type: "unsubscribe-view",
-        element,
-        scope
+        type: "unsubscribe-query",
+        subscriptionId
       }));
     }
   }
@@ -1667,17 +1709,17 @@ class EventWire {
           this.lastHostEventId = message.lastHostEventId;
         }
         break;
-      case "view-snapshot": {
-        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+      case "query-snapshot": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
         if (sub) {
-          sub.onSnapshot(message.items ?? []);
+          sub.callbacks.onSnapshot(message.result ?? null);
         }
         break;
       }
-      case "view-changes": {
-        const sub = this.viewSubscriptions.get(`${message.scope}:${message.element}`);
+      case "query-changes": {
+        const sub = this.querySubscriptions.get(message.subscriptionId);
         if (sub && Array.isArray(message.changes)) {
-          sub.onChanges(message.changes);
+          sub.callbacks.onChanges(message.changes);
         }
         break;
       }
@@ -1705,17 +1747,15 @@ class EventWire {
       this.pendingEvents = [];
     }
   }
-  sendAllViewSubscriptions() {
+  sendAllQuerySubscriptions() {
     if (!this.ws || this.state !== "connected")
       return;
-    for (const key of this.viewSubscriptions.keys()) {
-      const sepIdx = key.indexOf(":");
-      const scope = key.slice(0, sepIdx);
-      const element = key.slice(sepIdx + 1);
+    for (const [subscriptionId, sub] of this.querySubscriptions) {
       this.ws.send(JSON.stringify({
-        type: "subscribe-view",
-        element,
-        scope
+        type: "subscribe-query",
+        subscriptionId,
+        descriptor: sub.descriptor,
+        scope: sub.scope
       }));
     }
   }
@@ -1739,19 +1779,12 @@ 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;
   }
@@ -1819,19 +1852,7 @@ class LocalEventPublisher {
     });
     const viewChanges = await this.collectViewChanges(event);
     allChanges.push(...viewChanges);
-    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.dataStorage.commitChanges(allChanges);
     await this.notifySubscribers(event);
     if (this.syncCallback) {
       this.syncCallback(event);
@@ -2471,9 +2492,8 @@ class ArcObject extends ArcAbstract {
   }
 }
 class DataStorage {
-  async commitChanges(changes, _options) {
+  async commitChanges(changes) {
     await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
-    return [];
   }
 }
 
@@ -3564,6 +3584,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;
@@ -3719,12 +3781,8 @@ class MasterStoreState extends StoreState {
     }
     return transaction.find(this.storeName, { where: { _id: id2 } }).then((results) => results[0]);
   }
-  async applyChangeAndReturnEvent(transaction, change, transactionCache, options) {
+  async applyChangeAndReturnEvent(transaction, change, transactionCache) {
     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) {
@@ -3737,16 +3795,10 @@ 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}`);
@@ -3758,9 +3810,7 @@ class MasterStoreState extends StoreState {
           type: "delete",
           item: null,
           id: change.id
-        },
-        oldRow: existing ?? null,
-        newRow: null
+        }
       };
     }
     if (change.type === "modify") {
@@ -3778,9 +3828,7 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        },
-        oldRow: existing ?? null,
-        newRow: updated
+        }
       };
     }
     if (change.type === "mutate") {
@@ -3798,9 +3846,7 @@ class MasterStoreState extends StoreState {
           type: "set",
           item,
           id: change.id
-        },
-        oldRow: existing ?? null,
-        newRow: updated
+        }
       };
     }
     throw new Error("Unknown change type");
@@ -3878,22 +3924,17 @@ class MasterDataStorage extends DataStorage {
   applySerializedChanges(changes) {
     return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applySerializedChanges(changes2)));
   }
-  async commitChanges(changes, options) {
+  async commitChanges(changes) {
     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, oldRow, newRow } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache, { captureRows: capture });
+        const { event: event3 } = await storeState.applyChangeAndReturnEvent(transaction, change, transactionCache);
         if (event3)
           storeEvents.push(event3);
-        if (capture) {
-          committed.push({ store, id: event3.id, oldRow, newRow });
-        }
       }
       if (storeEvents.length > 0) {
         eventsByStore.set(store, storeEvents);
@@ -3904,7 +3945,6 @@ class MasterDataStorage extends DataStorage {
       const storeState = this.getStore(store);
       storeState.notifyListenersPublic(events);
     }
-    return committed;
   }
   fork() {
     return new ForkedDataStorage(this);
@@ -4019,8 +4059,8 @@ class ObservableDataStorage {
   getReadWriteTransaction() {
     return this.source.getReadWriteTransaction();
   }
-  commitChanges(changes, options) {
-    return this.source.commitChanges(changes, options);
+  commitChanges(changes) {
+    return this.source.commitChanges(changes);
   }
   trackQuery(storeName, options, result, listener4) {
     const key = this.getQueryKey(storeName, options);
@@ -4033,7 +4073,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;
@@ -4045,10 +4086,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();
@@ -4222,6 +4273,7 @@ class ScopedModel {
     for (const listener4 of this.tokenListeners) {
       listener4();
     }
+    return triggerModuleSync(this.scopeName);
   }
   getToken() {
     return this.authAdapter.getToken();
@@ -4319,244 +4371,135 @@ class Model {
     return s;
   }
 }
-var DEFAULT_SCOPE = "default";
-
-class StreamingQueryCache {
-  stores = new Map;
-  views = [];
-  activeStreams = new Map;
-  pendingUnsubscribes = new Map;
-  static UNSUBSCRIBE_DELAY_MS = 5000;
-  storeKey(viewName, scope) {
-    return `${scope ?? DEFAULT_SCOPE}:${viewName}`;
-  }
-  registerViews(views) {
-    this.views = views;
-  }
-  getStore(viewName, scope) {
-    const key = this.storeKey(viewName, scope);
-    if (!this.stores.has(key)) {
-      this.stores.set(key, 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);
     }
-    return this.stores.get(key);
-  }
-  hasData(viewName, scope) {
-    const store = this.stores.get(this.storeKey(viewName, scope));
-    return store ? store.hasData() : false;
   }
-  registerStream(key, createStream) {
-    const pending = this.pendingUnsubscribes.get(key);
-    if (pending) {
-      clearTimeout(pending);
-      this.pendingUnsubscribes.delete(key);
+  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);
     }
-    const existing = this.activeStreams.get(key);
-    if (existing) {
-      existing.refCount++;
-      return {
-        unsubscribe: () => this.unregisterStream(key),
-        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(key, {
-      unsubscribe: streamConn.unsubscribe,
-      refCount: 1
-    });
+    const subscribed = entry;
+    subscribed.listeners.add(onChange);
+    let active = true;
     return {
-      unsubscribe: () => this.unregisterStream(key),
-      wasReused: false
+      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);
+      }
     };
   }
-  unregisterStream(key) {
-    const stream = this.activeStreams.get(key);
-    if (!stream)
-      return;
-    stream.refCount--;
-    if (stream.refCount <= 0) {
-      const timeout = setTimeout(() => {
-        this.pendingUnsubscribes.delete(key);
-        const current2 = this.activeStreams.get(key);
-        if (current2 && current2.refCount <= 0) {
-          current2.unsubscribe();
-          this.activeStreams.delete(key);
-        }
-      }, StreamingQueryCache.UNSUBSCRIBE_DELAY_MS);
-      this.pendingUnsubscribes.set(key, timeout);
-    }
-  }
-  subscribeView(viewName, eventWire, scope) {
-    const key = this.storeKey(viewName, scope);
-    const { unsubscribe } = this.registerStream(key, () => {
-      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) {
+  invalidateScope(scope, eventWire) {
     const prefix = `${scope}:`;
-    for (const [key, timeout] of this.pendingUnsubscribes) {
-      if (!key.startsWith(prefix))
-        continue;
-      clearTimeout(timeout);
-      this.pendingUnsubscribes.delete(key);
-    }
-    for (const [key, stream] of this.activeStreams) {
+    for (const [key, entry] of this.entries) {
       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();
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
+      this.entries.delete(key);
+      entry.result = undefined;
+      entry.hasResult = false;
+      this.notify(entry);
     }
   }
-  async applyEvent(event3) {
-    for (const view3 of this.views) {
-      const handlers = view3.getHandlers();
-      const handler = handlers[event3.type];
-      if (!handler)
-        continue;
-      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(eventWire) {
+    for (const entry of this.entries.values()) {
+      if (entry.pendingUnsub)
+        clearTimeout(entry.pendingUnsub);
+      eventWire?.unsubscribeQuery(entry.subscriptionId);
     }
+    this.entries.clear();
   }
-  clear() {
-    for (const stream of this.activeStreams.values()) {
-      stream.unsubscribe();
-    }
-    this.activeStreams.clear();
-    for (const timeout of this.pendingUnsubscribes.values()) {
-      clearTimeout(timeout);
-    }
-    this.pendingUnsubscribes.clear();
-    for (const store of this.stores.values()) {
-      store.clear();
-    }
-  }
-}
-
-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);
-  }
-  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);
+  notify(entry) {
+    for (const listener4 of entry.listeners) {
+      try {
+        listener4();
+      } catch (err) {
+        console.error(`[Arc] Query cache listener error:`, err);
       }
     }
-    this.notifyListeners(events);
-  }
-  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 }]);
-    }
-  }
-  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);
-    }
   }
 }
 
 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-postgres",
-  "version": "0.7.15",
+  "version": "0.7.17",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,7 +23,7 @@
     "postgres": "^3.4.4"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.7.15"
+    "@arcote.tech/arc": "^0.7.17"
   },
   "devDependencies": {
     "@types/pg": "^8.11.0",