@welshman/app 0.12.5 → 0.13.0

package/dist/store/src/repository.js

@@ -1,7 +1,7 @@
-import { readable } from "svelte/store";
+import { derived, readable } from "svelte/store";
 import { on, gt, now, noop, mapPop, LRUCache, call, sortBy, first, } from "@welshman/lib";
 import { matchFilters, getIdFilters, sortEventsAsc, sortEventsDesc, getIdOrAddress, } from "@welshman/util";
-import { deriveDeduplicated } from "./misc.js";
+import { deriveDeduplicated, projection, projectFrom } from "./misc.js";
 export const getEventsById = ({ filters, repository, includeDeleted }) => {
     const eventsById = new Map();
     for (const event of repository.query(filters, { includeDeleted })) {
@@ -9,38 +9,42 @@ export const getEventsById = ({ filters, repository, includeDeleted }) => {
     }
     return eventsById;
 };
-export const deriveEventsById = ({ filters, repository, includeDeleted }) => readable(new Map(), set => {
-    const eventsById = getEventsById({ filters, repository, includeDeleted });
-    set(eventsById);
-    return on(repository, "update", ({ added, removed }) => {
-        let dirty = false;
-        for (const event of added) {
-            if (matchFilters(filters, event)) {
-                dirty = true;
-                eventsById.set(event.id, event);
-            }
-        }
-        if (!includeDeleted) {
-            for (const id of removed) {
-                if (mapPop(id, eventsById)) {
+export const deriveEventsById = (options) => {
+    const { filters, repository, includeDeleted } = options;
+    const store = readable(new Map(), set => {
+        const eventsById = getEventsById(options);
+        set(eventsById);
+        return on(repository, "update", ({ added, removed }) => {
+            let dirty = false;
+            for (const event of added) {
+                if (matchFilters(filters, event)) {
                     dirty = true;
+                    eventsById.set(event.id, event);
                 }
             }
-        }
-        if (dirty) {
-            set(eventsById);
-        }
+            if (!includeDeleted) {
+                for (const id of removed) {
+                    if (mapPop(id, eventsById)) {
+                        dirty = true;
+                    }
+                }
+            }
+            if (dirty) {
+                set(eventsById);
+            }
+        });
     });
-});
-export const deriveArray = (itemsByIdStore) => deriveDeduplicated(itemsByIdStore, itemsById => Array.from(itemsById.values()));
-export const deriveEventsAsc = (eventsByIdStore) => deriveDeduplicated(eventsByIdStore, eventsById => sortEventsAsc(eventsById.values()));
-export const deriveEventsDesc = (eventsByIdStore) => deriveDeduplicated(eventsByIdStore, eventsById => sortEventsDesc(eventsById.values()));
+    return projection(store, () => getEventsById(options));
+};
+export const deriveArray = (itemsById) => projectFrom(itemsById, $itemsById => Array.from($itemsById.values()));
+export const deriveEventsAsc = (eventsById) => projectFrom(eventsById, $eventsById => sortEventsAsc($eventsById.values()));
+export const deriveEventsDesc = (eventsById) => projectFrom(eventsById, $eventsById => sortEventsDesc($eventsById.values()));
 export const deriveEvents = (options) => deriveArray(deriveEventsById(options));
 export const makeDeriveEvent = ({ repository, includeDeleted = false, onDerive }) => {
     return (idOrAddress, ...args) => {
         const filters = getIdFilters([idOrAddress]);
         onDerive?.(filters, ...args);
-        return readable(undefined, set => {
+        const store = readable(undefined, set => {
             let event = first(repository.query(filters, { includeDeleted }));
             set(event);
             return on(repository, "update", ({ added, removed }) => {
@@ -59,6 +63,7 @@ export const makeDeriveEvent = ({ repository, includeDeleted = false, onDerive }
                 }
             });
         });
+        return projection(store, () => first(repository.query(filters, { includeDeleted })));
     };
 };
 export const getEventsByIdByUrl = ({ filters, tracker, repository, includeDeleted, }) => {
@@ -75,97 +80,107 @@ export const getEventsByIdByUrl = ({ filters, tracker, repository, includeDelete
     }
     return eventsByIdByUrl;
 };
-export const deriveEventsByIdByUrl = ({ filters, tracker, repository, includeDeleted, }) => readable(new Map(), set => {
-    const eventsByIdByUrl = getEventsByIdByUrl({ filters, tracker, repository, includeDeleted });
-    const addEvent = (url, event) => {
-        if (!matchFilters(filters, event))
-            return false;
-        const eventsById = eventsByIdByUrl.get(url);
-        // The repository swaps a changed copy of a held event in under the same id.
-        if (eventsById?.get(event.id) === event)
-            return false;
-        // Create a new map so we can detect which key changed
-        const newEventsById = new Map(eventsById);
-        newEventsById.set(event.id, event);
-        eventsByIdByUrl.set(url, newEventsById);
-        return true;
-    };
-    const removeEvent = (url, id) => {
-        const eventsById = eventsByIdByUrl.get(url);
-        if (eventsById?.has(id)) {
-            eventsById.delete(id);
-            if (eventsById.size === 0) {
-                eventsByIdByUrl.delete(url);
-            }
-            else {
-                // Create a new map so we can detect which key changed
-                eventsByIdByUrl.set(url, new Map(eventsById));
-            }
+export const deriveEventsByIdByUrl = (options) => {
+    const { filters, tracker, repository, includeDeleted } = options;
+    const store = readable(new Map(), set => {
+        const eventsByIdByUrl = getEventsByIdByUrl(options);
+        const addEvent = (url, event) => {
+            if (!matchFilters(filters, event))
+                return false;
+            const eventsById = eventsByIdByUrl.get(url);
+            // The repository swaps a changed copy of a held event in under the same id.
+            if (eventsById?.get(event.id) === event)
+                return false;
+            // Create a new map so we can detect which key changed
+            const newEventsById = new Map(eventsById);
+            newEventsById.set(event.id, event);
+            eventsByIdByUrl.set(url, newEventsById);
             return true;
-        }
-        return false;
-    };
-    set(eventsByIdByUrl);
-    const unsubscribers = [
-        on(repository, "update", ({ added, removed }) => {
-            let dirty = false;
-            for (const event of added) {
-                for (const url of tracker.getRelays(event.id)) {
-                    dirty = dirty || addEvent(url, event);
+        };
+        const removeEvent = (url, id) => {
+            const eventsById = eventsByIdByUrl.get(url);
+            if (eventsById?.has(id)) {
+                eventsById.delete(id);
+                if (eventsById.size === 0) {
+                    eventsByIdByUrl.delete(url);
                 }
+                else {
+                    // Create a new map so we can detect which key changed
+                    eventsByIdByUrl.set(url, new Map(eventsById));
+                }
+                return true;
             }
-            if (!includeDeleted) {
-                for (const id of removed) {
-                    for (const url of tracker.getRelays(id)) {
-                        dirty = dirty || removeEvent(url, id);
+            return false;
+        };
+        set(eventsByIdByUrl);
+        const unsubscribers = [
+            on(repository, "update", ({ added, removed }) => {
+                let dirty = false;
+                for (const event of added) {
+                    for (const url of tracker.getRelays(event.id)) {
+                        dirty = addEvent(url, event) || dirty;
+                    }
+                }
+                if (!includeDeleted) {
+                    for (const id of removed) {
+                        for (const url of tracker.getRelays(id)) {
+                            dirty = removeEvent(url, id) || dirty;
+                        }
+                    }
+                }
+                if (dirty) {
+                    set(eventsByIdByUrl);
+                }
+            }),
+            on(tracker, "add", (id, url) => {
+                const event = repository.getEvent(id);
+                if (event && addEvent(url, event)) {
+                    set(eventsByIdByUrl);
+                }
+            }),
+            on(tracker, "remove", (id, url) => {
+                if (removeEvent(url, id)) {
+                    set(eventsByIdByUrl);
+                }
+            }),
+            on(tracker, "load", () => {
+                eventsByIdByUrl.clear();
+                for (const event of repository.query(filters, { includeDeleted })) {
+                    for (const url of tracker.getRelays(event.id)) {
+                        addEvent(url, event);
                     }
                 }
-            }
-            if (dirty) {
-                set(eventsByIdByUrl);
-            }
-        }),
-        on(tracker, "add", (id, url) => {
-            const event = repository.getEvent(id);
-            if (event && addEvent(url, event)) {
                 set(eventsByIdByUrl);
-            }
-        }),
-        on(tracker, "remove", (id, url) => {
-            if (removeEvent(url, id)) {
+            }),
+            on(tracker, "clear", () => {
+                eventsByIdByUrl.clear();
                 set(eventsByIdByUrl);
-            }
-        }),
-        on(tracker, "load", () => {
-            eventsByIdByUrl.clear();
-            for (const event of repository.query(filters, { includeDeleted })) {
-                for (const url of tracker.getRelays(event.id)) {
-                    addEvent(url, event);
-                }
-            }
-            set(eventsByIdByUrl);
-        }),
-        on(tracker, "clear", () => {
-            eventsByIdByUrl.clear();
-            set(eventsByIdByUrl);
-        }),
-    ];
-    return () => unsubscribers.forEach(call);
-});
+            }),
+        ];
+        return () => unsubscribers.forEach(call);
+    });
+    return projection(store, () => getEventsByIdByUrl(options));
+};
+/**
+ * The events one relay has been seen to hold, narrowed by the filters. The filters choose the
+ * index and the tracker answers provenance per event, so the cost tracks what the caller asked
+ * for, and a limit counts only events on the relay.
+ */
 export const getEventsByIdForUrl = ({ url, filters, tracker, repository, includeDeleted, }) => {
-    const initialIds = Array.from(tracker.getIds(url));
-    const initialFilters = filters.map(filter => ({ ids: initialIds, ...filter }));
     const eventsById = new Map();
-    for (const event of repository.query(initialFilters, { includeDeleted })) {
+    const where = (event) => tracker.hasRelay(event.id, url);
+    for (const event of repository.query(filters, { includeDeleted, where })) {
         eventsById.set(event.id, event);
     }
     return eventsById;
 };
-export const deriveEventsByIdForUrl = ({ url, filters, tracker, repository, includeDeleted, }) => {
-    let eventsById = getEventsByIdForUrl({ url, filters, tracker, repository, includeDeleted });
-    return readable(eventsById, set => {
+export const deriveEventsByIdForUrl = (options) => {
+    const { url, filters, tracker, repository, includeDeleted } = options;
+    const belongs = (event) => tracker.hasRelay(event.id, url) && matchFilters(filters, event);
+    let eventsById = getEventsByIdForUrl(options);
+    const store = readable(eventsById, set => {
         const reset = () => {
-            eventsById = getEventsByIdForUrl({ url, filters, tracker, repository, includeDeleted });
+            eventsById = getEventsByIdForUrl(options);
             set(eventsById);
         };
         reset();
@@ -173,7 +188,7 @@ export const deriveEventsByIdForUrl = ({ url, filters, tracker, repository, incl
             on(repository, "update", ({ added, removed }) => {
                 let dirty = false;
                 for (const event of added) {
-                    if (tracker.hasRelay(event.id, url) && matchFilters(filters, event)) {
+                    if (belongs(event)) {
                         eventsById.set(event.id, event);
                         dirty = true;
                     }
@@ -193,7 +208,7 @@ export const deriveEventsByIdForUrl = ({ url, filters, tracker, repository, incl
             on(tracker, "add", (id, trackedUrl) => {
                 if (trackedUrl === url) {
                     const event = repository.getEvent(id);
-                    if (event && tracker.hasRelay(id, trackedUrl) && matchFilters(filters, event)) {
+                    if (event && belongs(event)) {
                         eventsById.set(id, event);
                         set(eventsById);
                     }
@@ -210,50 +225,95 @@ export const deriveEventsByIdForUrl = ({ url, filters, tracker, repository, incl
         ];
         return () => unsubscribers.forEach(call);
     });
+    return projection(store, () => getEventsByIdForUrl(options));
+};
+const asCollection = (store, pending) => {
+    const self = projection(store);
+    // Subscribing queues the parses, so a key the index lacks is read, drained, and read again
+    const read = (key) => self.get().get(key) ?? Promise.all(pending.values()).then(() => self.get().get(key));
+    return { ...self, read };
+};
+const onParseError = (error) => console.warn("Failed to build an item from an event", error);
+/**
+ * Build `event`'s item and pass it to `commit`, synchronously when the parse needs no IO.
+ * An async parse waits in `pending`, and deleting its entry there cancels the commit.
+ */
+const buildItem = (event, eventToItem, pending, commit) => {
+    let changed = false;
+    try {
+        const itemOrPromise = eventToItem(event);
+        if (itemOrPromise instanceof Promise) {
+            const isPending = () => pending.get(event.id) === parse;
+            const parse = itemOrPromise
+                .then(item => {
+                if (isPending())
+                    commit(item);
+            })
+                .catch(onParseError)
+                .finally(() => {
+                if (isPending())
+                    pending.delete(event.id);
+            });
+            pending.set(event.id, parse);
+        }
+        else {
+            changed = Boolean(commit(itemOrPromise));
+        }
+    }
+    catch (error) {
+        onParseError(error);
+    }
+    return changed;
 };
 export const deriveItemsByKey = ({ getKey, filters, repository, eventToItem, includeDeleted, }) => {
-    const deferred = new Map();
+    const pending = new Map();
     const itemsByKey = new Map();
-    const idsByKey = new Map();
-    const keysById = new Map();
-    return readable(itemsByKey, set => {
-        const onError = (error) => console.warn("Failed to build an item from an event", error);
+    // The event owning each key, so removing a superseded event leaves its successor's entry
+    const ownerByKey = new Map();
+    // The key each event contributed, for teardown.
+    const keyById = new Map();
+    const store = readable(itemsByKey, set => {
+        const commit = (id, item) => {
+            if (item) {
+                const key = getKey(item);
+                itemsByKey.set(key, item);
+                ownerByKey.set(key, id);
+                keyById.set(id, key);
+                set(itemsByKey);
+            }
+        };
         const addEvent = (event) => {
-            if (deferred.has(event.id))
-                return;
-            if (keysById.has(event.id))
-                return;
-            const commit = (item) => {
-                if (item) {
-                    const key = getKey(item);
-                    itemsByKey.set(key, item);
-                    idsByKey.set(key, event.id);
-                    keysById.set(event.id, key);
-                    set(itemsByKey);
-                }
-            };
-            try {
-                const itemOrPromise = eventToItem(event);
-                // Commit synchronously when `eventToItem` doesn't need IO, so items are in
-                // place before the initial subscription returns rather than a microtask later
-                if (itemOrPromise instanceof Promise) {
-                    deferred.set(event.id, itemOrPromise);
-                    itemOrPromise
-                        .then(commit)
-                        .catch(onError)
-                        .finally(() => deferred.delete(event.id));
-                }
-                else {
-                    commit(itemOrPromise);
+            if (!pending.has(event.id) && !keyById.has(event.id)) {
+                buildItem(event, eventToItem, pending, item => commit(event.id, item));
+            }
+        };
+        const removeEvent = (id) => {
+            const key = mapPop(id, keyById);
+            const owns = key !== undefined && ownerByKey.get(key) === id;
+            pending.delete(id);
+            if (owns) {
+                ownerByKey.delete(key);
+                itemsByKey.delete(key);
+            }
+            return owns;
+        };
+        // The index outlives a subscription, so a subscribe drops what left the repository meanwhile
+        const catchUp = () => {
+            const events = repository.query(filters, { includeDeleted });
+            const ids = new Set(events.map(event => event.id));
+            let dirty = false;
+            for (const id of Array.from(keyById.keys())) {
+                if (!ids.has(id)) {
+                    dirty = removeEvent(id) || dirty;
                 }
             }
-            catch (error) {
-                onError(error);
+            if (dirty)
+                set(itemsByKey);
+            for (const event of events) {
+                addEvent(event);
             }
         };
-        for (const event of repository.query(filters, { includeDeleted })) {
-            addEvent(event);
-        }
+        catchUp();
         return on(repository, "update", ({ added, removed }) => {
             for (const event of added) {
                 if (matchFilters(filters, event)) {
@@ -263,15 +323,7 @@ export const deriveItemsByKey = ({ getKey, filters, repository, eventToItem, inc
             if (!includeDeleted) {
                 let dirty = false;
                 for (const id of removed) {
-                    const key = mapPop(id, keysById);
-                    // Only remove if this id still owns the key — replacing a replaceable event
-                    // reports the old id as removed in the same update that adds the new one,
-                    // and the newer event has already taken the key over.
-                    if (key && idsByKey.get(key) === id) {
-                        idsByKey.delete(key);
-                        itemsByKey.delete(key);
-                        dirty = true;
-                    }
+                    dirty = removeEvent(id) || dirty;
                 }
                 if (dirty) {
                     set(itemsByKey);
@@ -279,6 +331,7 @@ export const deriveItemsByKey = ({ getKey, filters, repository, eventToItem, inc
             }
         });
     });
+    return asCollection(store, pending);
 };
 /**
  * Like `deriveItemsByKey`, but relay-scoped: an event is keyed once per relay
@@ -288,14 +341,17 @@ export const deriveItemsByKey = ({ getKey, filters, repository, eventToItem, inc
  * on multiple relays.
  */
 export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, tracker, eventToItem, includeDeleted, revalidateOn, }) => {
-    const deferred = new Set();
+    const pending = new Map();
     const itemsByKey = new Map();
-    // Which event currently owns each composite key, so a stale event's removal
-    // doesn't clobber the entry a newer replaceable event has taken over.
+    // Which event currently owns each key, as in `deriveItemsByKey`.
     const ownerByKey = new Map();
-    // The composite keys contributed by each event, per relay url, for teardown.
+    // The key each event contributed on each relay url, for teardown.
     const keysById = new Map();
-    return readable(itemsByKey, set => {
+    // What each event parsed to, so a rebuild re-keys it without parsing it again.
+    const itemsById = new Map();
+    const store = readable(itemsByKey, set => {
+        // Held while a catch-up keys its events, so a rebuild emits once rather than per event
+        let holding = false;
         const setKey = (key, id, url, item) => {
             itemsByKey.set(key, item);
             ownerByKey.set(key, id);
@@ -316,49 +372,42 @@ export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, tracker, ev
             }
             return false;
         };
-        const onError = (error) => console.warn("Failed to build an item from an event", error);
-        const addEvent = (event, urls) => {
-            const pending = Array.from(urls).filter(url => keysById.get(event.id)?.get(url) === undefined);
-            if (pending.length === 0)
-                return;
-            if (deferred.has(event.id))
-                return;
-            const commit = (item) => {
-                if (item) {
-                    for (const url of pending) {
-                        const key = getKey(item, url);
-                        if (key !== undefined) {
-                            setKey(key, event.id, url, item);
-                        }
+        // Keys the item on each tracked relay it lacks a key for, including relays seen mid-parse
+        const commit = (id, item) => {
+            let keyed = false;
+            if (item) {
+                itemsById.set(id, item);
+                for (const url of tracker.getRelays(id)) {
+                    const key = keysById.get(id)?.has(url) ? undefined : getKey(item, url);
+                    if (key !== undefined) {
+                        setKey(key, id, url, item);
+                        keyed = true;
                     }
-                    set(itemsByKey);
-                }
-            };
-            try {
-                const itemOrPromise = eventToItem(event);
-                // Commit synchronously when `eventToItem` doesn't need IO, so items are in
-                // place before the initial subscription returns rather than a microtask later
-                if (itemOrPromise instanceof Promise) {
-                    deferred.add(event.id);
-                    itemOrPromise
-                        .then(commit)
-                        .catch(onError)
-                        .finally(() => deferred.delete(event.id));
-                }
-                else {
-                    commit(itemOrPromise);
                 }
+                // Emit only when some url keyed the item
+                if (keyed && !holding)
+                    set(itemsByKey);
+            }
+            return keyed;
+        };
+        const addEvent = (event) => {
+            const parsed = itemsById.get(event.id);
+            let keyed = false;
+            // A rebuild clears the keys and keeps the items, so re-keying needs no parse
+            if (parsed) {
+                keyed = commit(event.id, parsed);
             }
-            catch (error) {
-                onError(error);
+            else if (!pending.has(event.id)) {
+                keyed = buildItem(event, eventToItem, pending, item => commit(event.id, item));
             }
+            return keyed;
         };
         const removeEvent = (id) => {
             const byUrl = mapPop(id, keysById);
-            if (!byUrl)
-                return false;
             let dirty = false;
-            for (const key of byUrl.values()) {
+            pending.delete(id);
+            itemsById.delete(id);
+            for (const key of byUrl?.values() ?? []) {
                 dirty = dropKey(key, id) || dirty;
             }
             return dirty;
@@ -374,21 +423,37 @@ export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, tracker, ev
             }
             return dropKey(key, id);
         };
-        const rebuild = () => {
+        const catchUp = (cleared = false) => {
+            const events = repository.query(filters, { includeDeleted });
+            const ids = new Set(events.map(event => event.id));
+            let dirty = cleared;
+            for (const id of Array.from(keysById.keys())) {
+                if (!ids.has(id)) {
+                    dirty = removeEvent(id) || dirty;
+                }
+            }
+            holding = true;
+            for (const event of events) {
+                dirty = addEvent(event) || dirty;
+            }
+            holding = false;
+            if (dirty)
+                set(itemsByKey);
+        };
+        const clear = () => {
+            const dirty = itemsByKey.size > 0;
             itemsByKey.clear();
             ownerByKey.clear();
             keysById.clear();
-            for (const event of repository.query(filters, { includeDeleted })) {
-                addEvent(event, tracker.getRelays(event.id));
-            }
-            set(itemsByKey);
+            return dirty;
         };
-        rebuild();
+        const rebuild = () => catchUp(clear());
+        catchUp();
         const unsubscribers = [
             on(repository, "update", ({ added, removed }) => {
                 for (const event of added) {
                     if (matchFilters(filters, event)) {
-                        addEvent(event, tracker.getRelays(event.id));
+                        addEvent(event);
                     }
                 }
                 if (!includeDeleted) {
@@ -403,7 +468,7 @@ export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, tracker, ev
             on(tracker, "add", (id, url) => {
                 const event = repository.getEvent(id);
                 if (event && matchFilters(filters, event)) {
-                    addEvent(event, [url]);
+                    addEvent(event);
                 }
             }),
             on(tracker, "remove", (id, url) => {
@@ -413,10 +478,8 @@ export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, tracker, ev
             }),
             on(tracker, "load", rebuild),
             on(tracker, "clear", () => {
-                itemsByKey.clear();
-                ownerByKey.clear();
-                keysById.clear();
-                set(itemsByKey);
+                if (clear())
+                    set(itemsByKey);
             }),
         ];
         // Re-evaluate everything when external key state (e.g. relay self pubkeys)
@@ -435,9 +498,10 @@ export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, tracker, ev
         }
         return () => unsubscribers.forEach(call);
     });
+    return asCollection(store, pending);
 };
-export const deriveItems = (itemsByKeyStore) => deriveDeduplicated(itemsByKeyStore, itemsByKey => Array.from(itemsByKey.values()));
-export const deriveItemsSorted = (sortFn, itemsStore) => deriveDeduplicated(itemsStore, items => sortBy(sortFn, items));
+export const deriveItems = (itemsByKeyStore) => derived(itemsByKeyStore, itemsByKey => Array.from(itemsByKey.values()));
+export const deriveItemsSorted = (sortFn, itemsStore) => derived(itemsStore, items => sortBy(sortFn, items));
 export const makeDeriveItem = (itemsByKeyStore, onDerive) => {
     return (key, ...args) => {
         if (!key)
@@ -464,7 +528,7 @@ export const makeLoadItem = (loadItem, getItem, options = {}) => {
     const attempts = new LRUCache(maxSize);
     const pending = new Map();
     return async (key, ...args) => {
-        const stale = getItem(key);
+        const stale = await getItem(key);
         // If we have an item, reload if it's relatively recent
         if (stale && getFetched(key) > now() - timeout) {
             return stale;
@@ -499,7 +563,7 @@ export const makeLoadItem = (loadItem, getItem, options = {}) => {
     };
 };
 // Miscellaneous other stuff
-export const deriveIsDeleted = (repository, event) => readable(false, set => {
+export const deriveIsDeleted = (repository, event) => projection(readable(false, set => {
     const idOrAddress = getIdOrAddress(event);
     set(repository.isDeleted(event));
     return on(repository, "update", ({ removed, added }) => {
@@ -512,5 +576,5 @@ export const deriveIsDeleted = (repository, event) => readable(false, set => {
             }
         }
     });
-});
+}), () => repository.isDeleted(event));
 //# sourceMappingURL=repository.js.map