@welshman/signer 0.14.0-pre3 → 0.14.0-pre5

package/dist/store/src/derive.js

@@ -0,0 +1,706 @@
+import { on, gt, now, noop, defer, mapPop, LRUCache, call, sortBy, first, batch, indexBy, omit, } from "@welshman/lib";
+import { getIdFilters, sortEventsAsc, sortEventsDesc, getIdOrAddress } from "@welshman/util";
+import { derived, readable } from "./svelte.js";
+import { deriveDeduplicated, projection, projectFrom } from "./misc.js";
+/** Build an `AsyncProjection` derived from another, whose `load` reads `src` fresh. */
+export const projectAsync = (src, read) => ({ ...projectFrom(src, read), load: async () => read(await src.load()) });
+// The filters narrowed to `ids` and unlimited, for checking which of them match
+const narrowFilters = (filters, ids) => filters.map(filter => ({
+    ...omit(["limit"], filter),
+    ids: filter.ids ? filter.ids.filter(id => ids.includes(id)) : ids,
+}));
+export const getEventsById = async ({ filters, repository, includeDeleted }) => {
+    const events = await repository.query(filters, { includeDeleted });
+    return indexBy(event => event.id, events);
+};
+// Keeps `eventsById` in step with the repository, refilling it when the read answers
+const syncEventsById = (eventsById, set) => ({
+    onLoad: events => {
+        eventsById.clear();
+        for (const event of events) {
+            eventsById.set(event.id, event);
+        }
+        set(eventsById);
+    },
+    onUpdate: ({ added, removed }) => {
+        let dirty = false;
+        for (const event of added) {
+            eventsById.set(event.id, event);
+            dirty = true;
+        }
+        for (const id of removed) {
+            dirty = eventsById.delete(id) || dirty;
+        }
+        if (dirty) {
+            set(eventsById);
+        }
+    },
+});
+/** The events matching `filters`, kept current. It holds its last value until the read answers. */
+export const deriveEventsById = (options) => {
+    const { filters, repository, includeDeleted } = options;
+    const eventsById = new Map();
+    const $ = readable(eventsById, set => repository.observe({ filters, includeDeleted, ...syncEventsById(eventsById, set) }));
+    return { ...projection($, () => eventsById), load: () => getEventsById(options) };
+};
+/** Calls `onEvents` with the matches once the read answers, then on each change, until stopped. */
+export const observeEventsById = ({ filters, repository, includeDeleted, onEvents, }) => {
+    const { onLoad, onUpdate } = syncEventsById(new Map(), onEvents);
+    let loaded = false;
+    return repository.observe({
+        filters,
+        includeDeleted,
+        onLoad: events => {
+            loaded = true;
+            onLoad(events);
+        },
+        // What changes before the read answers is in what onLoad receives
+        onUpdate: update => {
+            if (loaded) {
+                onUpdate(update);
+            }
+        },
+    });
+};
+const toArray = (itemsById) => Array.from(itemsById.values());
+export const deriveArray = (itemsById) => projectFrom(itemsById, toArray);
+export const deriveEventsArray = (eventsById) => projectAsync(eventsById, toArray);
+export const deriveEventsAsc = (eventsById) => projectAsync(eventsById, $eventsById => sortEventsAsc($eventsById.values()));
+export const deriveEventsDesc = (eventsById) => projectAsync(eventsById, $eventsById => sortEventsDesc($eventsById.values()));
+export const deriveEvents = (options) => deriveEventsArray(deriveEventsById(options));
+export const makeDeriveEvent = ({ repository, includeDeleted = false, onDerive }) => {
+    return (idOrAddress, ...args) => {
+        const filters = getIdFilters([idOrAddress]);
+        const load = async () => {
+            const events = await repository.query(filters, { includeDeleted });
+            return first(events);
+        };
+        let event;
+        onDerive?.(filters, ...args);
+        const $ = readable(event, set => repository.observe({
+            filters,
+            includeDeleted,
+            onLoad: events => {
+                event = first(events);
+                set(event);
+            },
+            onUpdate: ({ added, removed }) => {
+                if (event && removed.has(event.id)) {
+                    event = undefined;
+                    set(event);
+                }
+                for (const newEvent of added) {
+                    event = newEvent;
+                    set(event);
+                }
+            },
+        }));
+        return { ...projection($, () => event), load };
+    };
+};
+export const getEventsByIdByUrl = async ({ filters, repository, includeDeleted, }) => {
+    const eventsByIdByUrl = new Map();
+    const events = await repository.query(filters, { includeDeleted });
+    for (const event of events) {
+        for (const url of repository.tracker.getRelays(event.id)) {
+            let eventsById = eventsByIdByUrl.get(url);
+            if (!eventsById) {
+                eventsById = new Map();
+                eventsByIdByUrl.set(url, eventsById);
+            }
+            eventsById.set(event.id, event);
+        }
+    }
+    return eventsByIdByUrl;
+};
+/** The events matching `filters`, grouped by each relay the tracker has seen them on. */
+export const deriveEventsByIdByUrl = (options) => {
+    const { filters, repository, includeDeleted } = options;
+    const { tracker } = repository;
+    let eventsByIdByUrl = new Map();
+    const $ = readable(eventsByIdByUrl, set => {
+        // Every match, keyed or not, so a relay seen later can key it
+        const matched = new Map();
+        const addEvent = (url, event) => {
+            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));
+                }
+                return true;
+            }
+            return false;
+        };
+        const observe = () => repository.observe({
+            filters,
+            includeDeleted,
+            onLoad: events => {
+                matched.clear();
+                eventsByIdByUrl = new Map();
+                for (const event of events) {
+                    matched.set(event.id, event);
+                    for (const url of tracker.getRelays(event.id)) {
+                        addEvent(url, event);
+                    }
+                }
+                set(eventsByIdByUrl);
+            },
+            onUpdate: ({ added, removed }) => {
+                let dirty = false;
+                for (const event of added) {
+                    matched.set(event.id, event);
+                    for (const url of tracker.getRelays(event.id)) {
+                        dirty = addEvent(url, event) || dirty;
+                    }
+                }
+                for (const id of removed) {
+                    matched.delete(id);
+                    for (const url of tracker.getRelays(id)) {
+                        dirty = removeEvent(url, id) || dirty;
+                    }
+                }
+                if (dirty) {
+                    set(eventsByIdByUrl);
+                }
+            },
+        });
+        let stop = observe();
+        const unsubscribers = [
+            on(tracker, "add", (id, url) => {
+                const event = matched.get(id);
+                if (event && addEvent(url, event)) {
+                    set(eventsByIdByUrl);
+                }
+            }),
+            on(tracker, "remove", (id, url) => {
+                if (removeEvent(url, id)) {
+                    set(eventsByIdByUrl);
+                }
+            }),
+            on(tracker, "load", () => {
+                stop();
+                stop = observe();
+            }),
+            on(tracker, "clear", () => {
+                eventsByIdByUrl = new Map();
+                set(eventsByIdByUrl);
+            }),
+        ];
+        return () => {
+            stop();
+            unsubscribers.forEach(call);
+        };
+    });
+    return { ...projection($, () => eventsByIdByUrl), load: () => getEventsByIdByUrl(options) };
+};
+/** The events one relay has been seen to hold, with any limit counting only those events. */
+export const getEventsByIdForUrl = async ({ url, filters, repository, includeDeleted, }) => {
+    const events = await repository.query(filters, { includeDeleted, relay: url });
+    return indexBy(event => event.id, events);
+};
+const onLookUpError = (error) => console.error("Failed to look up events seen on a relay", error);
+export const deriveEventsByIdForUrl = (options) => {
+    const { url, filters, repository, includeDeleted } = options;
+    const { tracker } = repository;
+    const eventsById = new Map();
+    const $ = readable(eventsById, set => {
+        const sync = syncEventsById(eventsById, set);
+        // Ids seen on the relay while the read is in flight, which the read may well answer itself
+        let seenWhileReading;
+        let stopped = false;
+        const observe = () => {
+            seenWhileReading = new Set();
+            return repository.observe({
+                filters,
+                includeDeleted,
+                relay: url,
+                onUpdate: sync.onUpdate,
+                onLoad: events => {
+                    const seen = seenWhileReading ?? [];
+                    seenWhileReading = undefined;
+                    sync.onLoad(events);
+                    for (const id of seen) {
+                        if (!eventsById.has(id)) {
+                            check(id);
+                        }
+                    }
+                },
+            });
+        };
+        // Look up stored events seen on the relay later, observing so a removal meanwhile stands
+        const lookUp = (ids) => {
+            const stopLookUp = repository.observe({
+                filters: narrowFilters(filters, ids),
+                includeDeleted,
+                onUpdate: noop,
+                onError: error => {
+                    stopLookUp();
+                    onLookUpError(error);
+                },
+                onLoad: events => {
+                    let dirty = false;
+                    stopLookUp();
+                    for (const event of events) {
+                        if (!stopped && tracker.hasRelay(event.id, url) && !eventsById.has(event.id)) {
+                            eventsById.set(event.id, event);
+                            dirty = true;
+                        }
+                    }
+                    if (dirty) {
+                        set(eventsById);
+                    }
+                },
+            });
+        };
+        const check = batch(100, (ids) => {
+            if (!stopped)
+                lookUp(ids);
+        });
+        const reset = () => {
+            stop();
+            stop = observe();
+        };
+        let stop = observe();
+        const unsubscribers = [
+            on(tracker, "add", (id, trackedUrl) => {
+                if (trackedUrl === url && !eventsById.has(id)) {
+                    if (seenWhileReading) {
+                        seenWhileReading.add(id);
+                    }
+                    else {
+                        check(id);
+                    }
+                }
+            }),
+            on(tracker, "remove", (id, trackedUrl) => {
+                if (trackedUrl === url && eventsById.delete(id)) {
+                    set(eventsById);
+                }
+            }),
+            on(tracker, "load", reset),
+            on(tracker, "clear", reset),
+        ];
+        return () => {
+            stopped = true;
+            stop();
+            unsubscribers.forEach(call);
+        };
+    });
+    return { ...projection($, () => eventsById), load: () => getEventsByIdForUrl(options) };
+};
+const asCollection = ($, itemsByKey, pending, repository) => {
+    const self = projection($, () => itemsByKey);
+    // While subscribed, wait out pending writes, then the query and the parses outstanding after it
+    const read = (key) => {
+        const writes = repository.pendingWrites();
+        return ((writes ? undefined : itemsByKey.get(key)) ??
+            call(async () => {
+                const unsubscribe = $.subscribe(noop);
+                try {
+                    await writes;
+                    if (!itemsByKey.has(key)) {
+                        await pending.get(QUERY);
+                        await Promise.all(pending.values());
+                    }
+                    return itemsByKey.get(key);
+                }
+                finally {
+                    unsubscribe();
+                }
+            }));
+    };
+    return { ...self, read };
+};
+const onParseError = (error) => console.warn("Failed to build an item from an event", error);
+// A sync parse's item, or undefined while an async one waits in `pending` to reach `later`
+const buildItem = (event, eventToItem, pending, later) => {
+    let item;
+    try {
+        const itemOrPromise = eventToItem(event);
+        if (itemOrPromise instanceof Promise) {
+            const isPending = () => pending.get(event.id) === parse;
+            const parse = itemOrPromise
+                .then(parsed => {
+                if (isPending())
+                    later(parsed);
+            })
+                .catch(onParseError)
+                .finally(() => {
+                if (isPending())
+                    pending.delete(event.id);
+            });
+            pending.set(event.id, parse);
+        }
+        else {
+            item = itemOrPromise;
+        }
+    }
+    catch (error) {
+        onParseError(error);
+    }
+    return item;
+};
+// The read a subscription starts is tracked with the parses, so `read` waits for both
+const QUERY = Symbol("query");
+const onCollectionError = (error) => console.error("Failed to read a collection", error);
+// Observe the repository, recording the read in `pending` until it answers or the observer stops
+const observePending = (repository, pending, options) => {
+    const loaded = defer();
+    const done = () => {
+        if (pending.get(QUERY) === loaded)
+            pending.delete(QUERY);
+    };
+    pending.set(QUERY, loaded);
+    const stop = repository.observe({
+        ...options,
+        onLoad: events => {
+            options.onLoad?.(events);
+            done();
+            loaded.resolve();
+        },
+        // A failed read leaves the index as it was, which is what a waiting `read` answers from
+        onError: error => {
+            onCollectionError(error);
+            done();
+            loaded.resolve();
+        },
+    });
+    return () => {
+        stop();
+        done();
+        loaded.resolve();
+    };
+};
+export const deriveItemsByKey = ({ getKey, filters, repository, eventToItem, includeDeleted, }) => {
+    const pending = new Map();
+    const itemsByKey = new Map();
+    // 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 $ = 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);
+            }
+            return Boolean(item);
+        };
+        const addEvent = (event) => {
+            let added = false;
+            if (!pending.has(event.id) && !keyById.has(event.id)) {
+                const item = buildItem(event, eventToItem, pending, parsed => {
+                    if (commit(event.id, parsed))
+                        set(itemsByKey);
+                });
+                added = commit(event.id, item);
+            }
+            return added;
+        };
+        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;
+        };
+        return observePending(repository, pending, {
+            filters,
+            includeDeleted,
+            // The index outlives a subscription, so a subscribe drops what left the repository meanwhile
+            onLoad: events => {
+                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;
+                    }
+                }
+                for (const event of events) {
+                    dirty = addEvent(event) || dirty;
+                }
+                if (dirty)
+                    set(itemsByKey);
+            },
+            onUpdate: ({ added, removed }) => {
+                let dirty = false;
+                for (const event of added) {
+                    dirty = addEvent(event) || dirty;
+                }
+                for (const id of removed) {
+                    dirty = removeEvent(id) || dirty;
+                }
+                if (dirty)
+                    set(itemsByKey);
+            },
+        });
+    });
+    return asCollection($, itemsByKey, pending, repository);
+};
+/** Like `deriveItemsByKey`, but keying each event once per relay the tracker has seen it on. */
+export const deriveItemsByKeyByUrl = ({ getKey, filters, repository, eventToItem, includeDeleted, revalidateOn, }) => {
+    const { tracker } = repository;
+    const pending = new Map();
+    const itemsByKey = new Map();
+    // Which event currently owns each key, as in `deriveItemsByKey`.
+    const ownerByKey = new Map();
+    // The key each event contributed on each relay url, for teardown.
+    const keysById = new Map();
+    // What each event parsed to, so re-keying it never parses it again
+    const itemsById = new Map();
+    const $ = readable(itemsByKey, set => {
+        const setKey = (key, id, url, item) => {
+            itemsByKey.set(key, item);
+            ownerByKey.set(key, id);
+            let byUrl = keysById.get(id);
+            if (!byUrl) {
+                byUrl = new Map();
+                keysById.set(id, byUrl);
+            }
+            byUrl.set(url, key);
+        };
+        const dropKey = (key, id) => {
+            // Only remove if this id still owns the key (guards against a replaceable
+            // event having already taken it over).
+            if (ownerByKey.get(key) === id) {
+                itemsByKey.delete(key);
+                ownerByKey.delete(key);
+                return true;
+            }
+            return false;
+        };
+        // 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;
+                    }
+                }
+            }
+            return keyed;
+        };
+        // Commit an item that arrives on its own, as a parse or a relay seen later
+        const commitAlone = (id, item) => {
+            if (commit(id, item))
+                set(itemsByKey);
+        };
+        const addEvent = (event) => {
+            const parsed = itemsById.get(event.id);
+            let keyed = false;
+            if (parsed) {
+                keyed = commit(event.id, parsed);
+            }
+            else if (!pending.has(event.id)) {
+                const item = buildItem(event, eventToItem, pending, later => commitAlone(event.id, later));
+                keyed = commit(event.id, item);
+            }
+            return keyed;
+        };
+        const removeEvent = (id) => {
+            const byUrl = mapPop(id, keysById);
+            let dirty = false;
+            pending.delete(id);
+            itemsById.delete(id);
+            for (const key of byUrl?.values() ?? []) {
+                dirty = dropKey(key, id) || dirty;
+            }
+            return dirty;
+        };
+        const removeEventUrl = (id, url) => {
+            const byUrl = keysById.get(id);
+            const key = byUrl?.get(url);
+            if (!byUrl || key === undefined)
+                return false;
+            byUrl.delete(url);
+            if (byUrl.size === 0) {
+                keysById.delete(id);
+            }
+            return dropKey(key, id);
+        };
+        const clear = () => {
+            const dirty = itemsByKey.size > 0;
+            itemsByKey.clear();
+            ownerByKey.clear();
+            keysById.clear();
+            return dirty;
+        };
+        const stop = observePending(repository, pending, {
+            filters,
+            includeDeleted,
+            onLoad: events => {
+                const ids = new Set(events.map(event => event.id));
+                let dirty = false;
+                for (const id of Array.from(itemsById.keys())) {
+                    if (!ids.has(id)) {
+                        dirty = removeEvent(id) || dirty;
+                    }
+                }
+                for (const event of events) {
+                    dirty = addEvent(event) || dirty;
+                }
+                if (dirty)
+                    set(itemsByKey);
+            },
+            onUpdate: ({ added, removed }) => {
+                let dirty = false;
+                for (const event of added) {
+                    dirty = addEvent(event) || dirty;
+                }
+                for (const id of removed) {
+                    dirty = removeEvent(id) || dirty;
+                }
+                if (dirty)
+                    set(itemsByKey);
+            },
+        });
+        // Re-key every parsed item, since the tracker's relays or `getKey`'s answers have changed
+        const rebuild = () => {
+            let dirty = clear();
+            for (const [id, item] of itemsById) {
+                dirty = commit(id, item) || dirty;
+            }
+            if (dirty)
+                set(itemsByKey);
+        };
+        const unsubscribers = [
+            on(tracker, "add", (id) => commitAlone(id, itemsById.get(id))),
+            on(tracker, "remove", (id, url) => {
+                if (removeEventUrl(id, url)) {
+                    set(itemsByKey);
+                }
+            }),
+            on(tracker, "load", rebuild),
+            on(tracker, "clear", () => {
+                if (clear())
+                    set(itemsByKey);
+            }),
+        ];
+        // Re-evaluate everything when external key state (e.g. relay self pubkeys)
+        // changes. The first emission fires synchronously on subscribe and is the
+        // initial state we already built, so skip it.
+        if (revalidateOn) {
+            let initialized = false;
+            unsubscribers.push(revalidateOn.subscribe(() => {
+                if (initialized) {
+                    rebuild();
+                }
+                else {
+                    initialized = true;
+                }
+            }));
+        }
+        return () => {
+            stop();
+            unsubscribers.forEach(call);
+        };
+    });
+    return asCollection($, itemsByKey, pending, repository);
+};
+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)
+            return readable(undefined);
+        // Nothing awaits this, so a failed load has nowhere to go
+        Promise.resolve(onDerive?.(key, ...args)).catch(noop);
+        return deriveDeduplicated(itemsByKeyStore, itemsByKey => itemsByKey.get(key));
+    };
+};
+export const makeForceLoadItem = (loadItem, getItem) => {
+    return async (key, ...args) => {
+        await loadItem(key, ...args);
+        return getItem(key);
+    };
+};
+export const makeLoadItem = (loadItem, getItem, options = {}) => {
+    const timeout = options.timeout || 3600;
+    const maxSize = options.maxSize || 10_000;
+    const fetched = new LRUCache(maxSize);
+    const getFetched = options.getFetched || ((key) => fetched.get(key) || 0);
+    const setFetched = options.setFetched || ((key, ts) => fetched.set(key, ts));
+    const getSource = options.getSource || ((...args) => JSON.stringify(args));
+    const sourceFetched = new LRUCache(maxSize);
+    const attempts = new LRUCache(maxSize);
+    const pending = new Map();
+    return async (key, ...args) => {
+        const stale = await getItem(key);
+        // If we have an item, reload if it's relatively recent
+        if (stale && getFetched(key) > now() - timeout) {
+            return stale;
+        }
+        const source = `${key}:${getSource(...args)}`;
+        const pendingItem = pending.get(source);
+        // If we already are loading from this source, await and return
+        if (pendingItem) {
+            return pendingItem;
+        }
+        const attempt = attempts.get(source) || 0;
+        // Use exponential backoff to throttle repeat attempts against the same source
+        if (gt(sourceFetched.get(source), now() - Math.pow(2, attempt))) {
+            return stale;
+        }
+        attempts.set(source, attempt + 1);
+        sourceFetched.set(source, now());
+        setFetched(key, now());
+        const promise = loadItem(key, ...args).then(() => getItem(key));
+        pending.set(source, promise);
+        let item;
+        try {
+            item = await promise;
+        }
+        finally {
+            pending.delete(source);
+        }
+        if (item) {
+            attempts.pop(source);
+        }
+        return item;
+    };
+};
+// Miscellaneous other stuff
+export const deriveIsDeleted = (repository, event) => projection(readable(false, set => {
+    const idOrAddress = getIdOrAddress(event);
+    set(repository.isDeleted(event));
+    const unsubscribers = [
+        on(repository, "update", ({ removed, added }) => {
+            if (removed.has(event.id)) {
+                set(true);
+            }
+            for (const event of added) {
+                if (getIdOrAddress(event) === idOrAddress) {
+                    set(false);
+                }
+            }
+        }),
+        on(repository, "clear", () => set(repository.isDeleted(event))),
+    ];
+    return () => unsubscribers.forEach(call);
+}), () => repository.isDeleted(event));
+//# sourceMappingURL=derive.js.map