applesauce-core 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1 @@
+# applesauce-core

package/dist/event-store/database.d.ts

@@ -1,34 +1,78 @@
+/// <reference types="debug" />
+/// <reference types="zen-observable" />
 import { Filter, NostrEvent } from "nostr-tools";
-import { LRU } from "tiny-lru";
+import { LRU } from "../utils/lru.js";
+/**
+ * An in-memory database for nostr events
+ */
 export declare class Database {
     log: import("debug").Debugger;
-    /** Max number of events to hold */
-    max?: number;
     /** Indexes */
-    kinds: Map<number, Set<import("nostr-tools").Event>>;
-    authors: Map<string, Set<import("nostr-tools").Event>>;
-    tags: LRU<Set<import("nostr-tools").Event>>;
-    created_at: NostrEvent[];
+    protected kinds: Map<number, Set<import("nostr-tools").Event>>;
+    protected authors: Map<string, Set<import("nostr-tools").Event>>;
+    protected tags: LRU<Set<import("nostr-tools").Event>>;
+    protected created_at: NostrEvent[];
     /** LRU cache of last events touched */
     events: LRU<import("nostr-tools").Event>;
-    constructor(max?: number);
+    private insertedSignal;
+    private deletedSignal;
+    /** A stream of events inserted into the database */
+    inserted: {
+        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
+        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
+        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
+        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
+        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
+        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
+        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
+        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
+        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
+        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
+    };
+    /** A stream of events removed of the database */
+    deleted: {
+        subscribe(observer: ZenObservable.Observer<import("nostr-tools").Event>): ZenObservable.Subscription;
+        subscribe(onNext: (value: import("nostr-tools").Event) => void, onError?: ((error: any) => void) | undefined, onComplete?: (() => void) | undefined): ZenObservable.Subscription;
+        forEach(callback: (value: import("nostr-tools").Event) => void): Promise<void>;
+        map<R>(callback: (value: import("nostr-tools").Event) => R): import("zen-observable")<R>;
+        filter<S extends import("nostr-tools").Event>(callback: (value: import("nostr-tools").Event) => value is S): import("zen-observable")<S>;
+        filter(callback: (value: import("nostr-tools").Event) => boolean): import("zen-observable")<import("nostr-tools").Event>;
+        reduce(callback: (previousValue: import("nostr-tools").Event, currentValue: import("nostr-tools").Event) => import("nostr-tools").Event, initialValue?: import("nostr-tools").Event | undefined): import("zen-observable")<import("nostr-tools").Event>;
+        reduce<R_1>(callback: (previousValue: R_1, currentValue: import("nostr-tools").Event) => R_1, initialValue?: R_1 | undefined): import("zen-observable")<R_1>;
+        flatMap<R_2>(callback: (value: import("nostr-tools").Event) => ZenObservable.ObservableLike<R_2>): import("zen-observable")<R_2>;
+        concat<R_3>(...observable: import("zen-observable")<R_3>[]): import("zen-observable")<R_3>;
+    };
+    protected claims: WeakMap<import("nostr-tools").Event, any>;
     /** Index helper methods */
-    private getKindIndex;
-    private getAuthorsIndex;
-    private getTagIndex;
+    protected getKindIndex(kind: number): Set<import("nostr-tools").Event>;
+    protected getAuthorsIndex(author: string): Set<import("nostr-tools").Event>;
+    protected getTagIndex(tagAndValue: string): Set<import("nostr-tools").Event>;
+    /** Moves an event to the top of the LRU cache */
     touch(event: NostrEvent): void;
     hasEvent(uid: string): import("nostr-tools").Event | undefined;
     getEvent(uid: string): import("nostr-tools").Event | undefined;
+    /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
+    /** Gets a replaceable event and touches it */
     getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
     addEvent(event: NostrEvent): import("nostr-tools").Event;
-    deleteEvent(eventOrId: string | NostrEvent): boolean;
+    deleteEvent(eventOrUID: string | NostrEvent): boolean;
+    /** Sets the claim on the event and touches it */
+    claimEvent(event: NostrEvent, claim: any): void;
+    /** Checks if an event is claimed by anything */
+    isClaimed(event: NostrEvent): boolean;
+    /** Removes a claim from an event */
+    removeClaim(event: NostrEvent, claim: any): void;
+    /** Removes all claims on an event */
+    clearClaim(event: NostrEvent): void;
     iterateAuthors(authors: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
     iterateTag(tag: string, values: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
     iterateKinds(kinds: Iterable<number>): Generator<import("nostr-tools").Event, void, unknown>;
     iterateTime(since: number | undefined, until: number | undefined): Generator<never, Set<import("nostr-tools").Event>, unknown>;
     iterateIds(ids: Iterable<string>): Generator<import("nostr-tools").Event, void, unknown>;
+    /** Returns all events that match the filter */
     getEventsForFilter(filter: Filter): Set<NostrEvent>;
     getForFilters(filters: Filter[]): Set<import("nostr-tools").Event>;
-    prune(): number | undefined;
+    /** Remove the oldest events that are not claimed */
+    prune(limit?: number): number;
 }

package/dist/event-store/database.js

@@ -1,12 +1,14 @@
-import { LRU } from "tiny-lru";
+import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import PushStream from "zen-push";
 import { getEventUID, getIndexableTags, getReplaceableUID } from "../helpers/event.js";
 import { INDEXABLE_TAGS } from "./common.js";
 import { logger } from "../logger.js";
-import { binarySearch, insertEventIntoDescendingList } from "nostr-tools/utils";
+import { LRU } from "../utils/lru.js";
+/**
+ * An in-memory database for nostr events
+ */
 export class Database {
     log = logger.extend("Database");
-    /** Max number of events to hold */
-    max;
     /** Indexes */
     kinds = new Map();
     authors = new Map();
@@ -14,9 +16,13 @@ export class Database {
     created_at = [];
     /** LRU cache of last events touched */
     events = new LRU();
-    constructor(max) {
-        this.max = max;
-    }
+    insertedSignal = new PushStream();
+    deletedSignal = new PushStream();
+    /** A stream of events inserted into the database */
+    inserted = this.insertedSignal.observable;
+    /** A stream of events removed of the database */
+    deleted = this.deletedSignal.observable;
+    claims = new WeakMap();
     /** Index helper methods */
     getKindIndex(kind) {
         if (!this.kinds.has(kind))
@@ -45,6 +51,7 @@ export class Database {
         }
         return this.tags.get(tagAndValue);
     }
+    /** Moves an event to the top of the LRU cache */
     touch(event) {
         this.events.set(getEventUID(event), event);
     }
@@ -54,9 +61,11 @@ export class Database {
     getEvent(uid) {
         return this.events.get(uid);
     }
+    /** Checks if the database contains a replaceable event without touching it */
     hasReplaceable(kind, pubkey, d) {
         return this.events.has(getReplaceableUID(kind, pubkey, d));
     }
+    /** Gets a replaceable event and touches it */
     getReplaceable(kind, pubkey, d) {
         return this.events.get(getReplaceableUID(kind, pubkey, d));
     }
@@ -74,10 +83,11 @@ export class Database {
             }
         }
         insertEventIntoDescendingList(this.created_at, event);
+        this.insertedSignal.next(event);
         return event;
     }
-    deleteEvent(eventOrId) {
-        let event = typeof eventOrId === "string" ? this.events.get(eventOrId) : eventOrId;
+    deleteEvent(eventOrUID) {
+        let event = typeof eventOrUID === "string" ? this.events.get(eventOrUID) : eventOrUID;
         if (!event)
             throw new Error("Missing event");
         const uid = getEventUID(event);
@@ -95,8 +105,31 @@ export class Database {
         const i = this.created_at.indexOf(event);
         this.created_at.splice(i, 1);
         this.events.delete(uid);
+        this.deletedSignal.next(event);
         return true;
     }
+    /** Sets the claim on the event and touches it */
+    claimEvent(event, claim) {
+        if (!this.claims.has(event)) {
+            this.claims.set(event, claim);
+        }
+        // always touch event
+        this.touch(event);
+    }
+    /** Checks if an event is claimed by anything */
+    isClaimed(event) {
+        return this.claims.has(event);
+    }
+    /** Removes a claim from an event */
+    removeClaim(event, claim) {
+        const current = this.claims.get(event);
+        if (current === claim)
+            this.claims.delete(event);
+    }
+    /** Removes all claims on an event */
+    clearClaim(event) {
+        this.claims.delete(event);
+    }
     *iterateAuthors(authors) {
         for (const author of authors) {
             const events = this.authors.get(author);
@@ -157,6 +190,7 @@ export class Database {
                 yield this.events.get(id);
         }
     }
+    /** Returns all events that match the filter */
     getEventsForFilter(filter) {
         // search is not supported, return an empty set
         if (filter.search)
@@ -224,16 +258,19 @@ export class Database {
         }
         return events;
     }
-    prune() {
-        if (!this.max)
-            return;
+    /** Remove the oldest events that are not claimed */
+    prune(limit = 1000) {
         let removed = 0;
-        while (this.events.size > this.max) {
-            const event = this.events.first;
-            if (event) {
+        let cursor = this.events.first;
+        while (cursor) {
+            const event = cursor.value;
+            if (!this.isClaimed(event)) {
                 this.deleteEvent(event);
                 removed++;
+                if (removed >= limit)
+                    break;
             }
+            cursor = cursor.next;
         }
         return removed;
     }

package/dist/event-store/event-store.d.ts

@@ -5,6 +5,7 @@ export declare class EventStore {
     events: Database;
     private singles;
     private streams;
+    private timelines;
     constructor();
     add(event: NostrEvent, fromRelay?: string): import("nostr-tools").Event;
     getAll(filters: Filter[]): Set<import("nostr-tools").Event>;
@@ -13,7 +14,7 @@ export declare class EventStore {
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
     getReplaceable(kind: number, pubkey: string, d?: string): import("nostr-tools").Event | undefined;
     /** Creates an observable that updates a single event */
-    single(uid: string): Observable<import("nostr-tools").Event>;
+    single(uid: string): Observable<import("nostr-tools").Event | undefined>;
     /** Creates an observable that streams all events that match the filter */
     stream(filters: Filter[]): Observable<import("nostr-tools").Event>;
     /** Creates an observable that updates with an array of sorted events */

package/dist/event-store/event-store.js

@@ -8,24 +8,12 @@ export class EventStore {
     events;
     singles = new Map();
     streams = new Map();
+    timelines = new Map();
     constructor() {
         this.events = new Database();
     }
     add(event, fromRelay) {
         const inserted = this.events.addEvent(event);
-        if (inserted === event) {
-            // forward to single event requests
-            const eventUID = getEventUID(event);
-            for (const [control, uid] of this.singles) {
-                if (eventUID === uid)
-                    control.next(event);
-            }
-            // forward to streams
-            for (const [control, filters] of this.streams) {
-                if (matchFilters(filters, event))
-                    control.next(event);
-            }
-        }
         if (fromRelay)
             addSeenRelay(inserted, fromRelay);
         return inserted;
@@ -47,34 +35,133 @@ export class EventStore {
     }
     /** Creates an observable that updates a single event */
     single(uid) {
-        return new Observable((control) => {
-            const event = this.events.getEvent(uid);
-            if (event)
-                control.next(event);
-            this.singles.set(control, uid);
+        return new Observable((observer) => {
+            let current = this.events.getEvent(uid);
+            if (current) {
+                observer.next(current);
+                this.events.claimEvent(current, observer);
+            }
+            // subscribe to future events
+            const inserted = this.events.inserted.subscribe((event) => {
+                if (getEventUID(event) === uid && (!current || event.created_at > current.created_at)) {
+                    // remove old claim
+                    if (current)
+                        this.events.removeClaim(current, observer);
+                    current = event;
+                    observer.next(event);
+                    // claim new event
+                    this.events.claimEvent(current, observer);
+                }
+            });
+            // subscribe to deleted events
+            const deleted = this.events.deleted.subscribe((event) => {
+                if (getEventUID(event) === uid && current) {
+                    this.events.removeClaim(current, observer);
+                    current = undefined;
+                    observer.next(undefined);
+                }
+            });
+            this.singles.set(observer, uid);
             return () => {
-                this.singles.delete(control);
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                this.singles.delete(observer);
+                if (current)
+                    this.events.removeClaim(current, observer);
             };
         });
     }
     /** Creates an observable that streams all events that match the filter */
     stream(filters) {
-        return new Observable((control) => {
-            const events = this.events.getForFilters(filters);
-            for (const event of events)
-                control.next(event);
-            this.streams.set(control, filters);
+        return new Observable((observer) => {
+            let claimed = new Set();
+            let events = this.events.getForFilters(filters);
+            for (const event of events) {
+                observer.next(event);
+                this.events.claimEvent(event, observer);
+                claimed.add(event);
+            }
+            // subscribe to future events
+            const sub = this.events.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    observer.next(event);
+                    this.events.claimEvent(event, observer);
+                    claimed.add(event);
+                }
+            });
+            this.streams.set(observer, filters);
             return () => {
-                this.streams.delete(control);
+                sub.unsubscribe();
+                this.streams.delete(observer);
+                // remove all claims
+                for (const event of claimed)
+                    this.events.removeClaim(event, observer);
+                claimed.clear();
             };
         });
     }
     /** Creates an observable that updates with an array of sorted events */
     timeline(filters) {
-        let events = [];
-        return this.stream(filters).map((event) => {
-            insertEventIntoDescendingList(events, event);
-            return events;
+        return new Observable((observer) => {
+            const seen = new Map();
+            const timeline = [];
+            // build initial timeline
+            const events = this.events.getForFilters(filters);
+            for (const event of events) {
+                insertEventIntoDescendingList(timeline, event);
+                this.events.claimEvent(event, observer);
+                seen.set(getEventUID(event), event);
+            }
+            observer.next([...timeline]);
+            // subscribe to future events
+            const inserted = this.events.inserted.subscribe((event) => {
+                if (matchFilters(filters, event)) {
+                    const uid = getEventUID(event);
+                    let current = seen.get(uid);
+                    if (current) {
+                        if (event.created_at > current.created_at) {
+                            // replace event
+                            timeline.splice(timeline.indexOf(current), 1, event);
+                            observer.next([...timeline]);
+                            // update the claim
+                            seen.set(uid, event);
+                            this.events.removeClaim(current, observer);
+                            this.events.claimEvent(event, observer);
+                        }
+                    }
+                    else {
+                        insertEventIntoDescendingList(timeline, event);
+                        observer.next([...timeline]);
+                        // claim new event
+                        this.events.claimEvent(event, observer);
+                        seen.set(getEventUID(event), event);
+                    }
+                }
+            });
+            // subscribe to removed events
+            const deleted = this.events.deleted.subscribe((event) => {
+                const uid = getEventUID(event);
+                let current = seen.get(uid);
+                if (current) {
+                    // remove the event
+                    timeline.splice(timeline.indexOf(current), 1);
+                    observer.next([...timeline]);
+                    // remove the claim
+                    seen.delete(uid);
+                    this.events.removeClaim(current, observer);
+                }
+            });
+            this.timelines.set(observer, filters);
+            return () => {
+                this.timelines.delete(observer);
+                inserted.unsubscribe();
+                deleted.unsubscribe();
+                // remove all claims
+                for (const [_, event] of seen) {
+                    this.events.removeClaim(event, observer);
+                }
+                seen.clear();
+            };
         });
     }
 }

package/dist/event-store/index.d.ts

@@ -1 +1,2 @@
-export * from './event-store.js';
+export * from "./event-store.js";
+export * from "./database.js";

package/dist/event-store/index.js

@@ -1 +1,2 @@
-export * from './event-store.js';
+export * from "./event-store.js";
+export * from "./database.js";

package/dist/helpers/event.d.ts

@@ -1,4 +1,8 @@
 import { NostrEvent } from "nostr-tools";
+/**
+ * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
+ * or parameterized replaceable ( 30000 <= n < 40000 )
+ */
 export declare function isReplaceable(kind: number): boolean;
 /** returns the events Unique ID */
 export declare function getEventUID(event: NostrEvent): string;

package/dist/helpers/event.js

@@ -1,6 +1,10 @@
 import { kinds } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
 import { EventIndexableTags, EventUID } from "./symbols.js";
+/**
+ * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
+ * or parameterized replaceable ( 30000 <= n < 40000 )
+ */
 export function isReplaceable(kind) {
     return kinds.isReplaceableKind(kind) || kinds.isParameterizedReplaceableKind(kind);
 }

package/dist/helpers/filter.d.ts

@@ -1,3 +1,8 @@
 import { Filter, NostrEvent } from "nostr-tools";
+/**
+ * Copied from nostr-tools and modified to use getIndexableTags
+ * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+ */
 export declare function matchFilter(filter: Filter, event: NostrEvent): boolean;
+/** Copied from nostr-tools */
 export declare function matchFilters(filters: Filter[], event: NostrEvent): boolean;

package/dist/helpers/filter.js

@@ -1,6 +1,8 @@
 import { getIndexableTags } from "./event.js";
-// Copied from https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
-// And modified to use getIndexableTags
+/**
+ * Copied from nostr-tools and modified to use getIndexableTags
+ * @see https://github.com/nbd-wtf/nostr-tools/blob/a61cde77eacc9518001f11d7f67f1a50ae05fd80/filter.ts
+ */
 export function matchFilter(filter, event) {
     if (filter.ids && filter.ids.indexOf(event.id) === -1) {
         return false;
@@ -28,6 +30,7 @@ export function matchFilter(filter, event) {
         return false;
     return true;
 }
+/** Copied from nostr-tools */
 export function matchFilters(filters, event) {
     for (let i = 0; i < filters.length; i++) {
         if (matchFilter(filters[i], event)) {

package/dist/helpers/index.d.ts

@@ -2,4 +2,5 @@ export * from "./profile.js";
 export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
+export * from "./mailboxes.js";
 export * as symbols from "./symbols.js";

package/dist/helpers/index.js

@@ -2,4 +2,5 @@ export * from "./profile.js";
 export * from "./relays.js";
 export * from "./event.js";
 export * from "./filter.js";
+export * from "./mailboxes.js";
 export * as symbols from "./symbols.js";

package/dist/helpers/mailboxes.d.ts

@@ -1,3 +1,9 @@
 import { NostrEvent } from "nostr-tools";
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxes} symbol
+ */
 export declare function getInboxes(event: NostrEvent): Set<string>;
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxes} symbol
+ */
 export declare function getOutboxes(event: NostrEvent): Set<string>;

package/dist/helpers/mailboxes.js

@@ -1,5 +1,8 @@
 import { safeRelayUrl } from "./relays.js";
 import { MailboxesInboxes, MailboxesOutboxes } from "./symbols.js";
+/**
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxes} symbol
+ */
 export function getInboxes(event) {
     if (!event[MailboxesInboxes]) {
         const inboxes = new Set();
@@ -14,6 +17,9 @@ export function getInboxes(event) {
     }
     return event[MailboxesInboxes];
 }
+/**
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxes} symbol
+ */
 export function getOutboxes(event) {
     if (!event[MailboxesOutboxes]) {
         const outboxes = new Set();

package/dist/query-store/index.d.ts

@@ -1,26 +1,26 @@
 import Observable from "zen-observable";
-import { LRU } from "tiny-lru";
 import { Filter, NostrEvent } from "nostr-tools";
 import { EventStore } from "../event-store/event-store.js";
 import { ProfileContent } from "../helpers/profile.js";
+import { LRU } from "../utils/lru.js";
 export declare class QueryStore {
     store: EventStore;
     constructor(store: EventStore);
-    singleEvents: LRU<Observable<import("nostr-tools").Event>>;
-    getEvent(id: string): Observable<import("nostr-tools").Event>;
-    getReplaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event>;
+    singleEvents: LRU<Observable<import("nostr-tools").Event | undefined>>;
+    getEvent(id: string): Observable<import("nostr-tools").Event | undefined>;
+    getReplaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
     timelines: LRU<Observable<import("nostr-tools").Event[]>>;
     getTimeline(filters: Filter[]): Observable<import("nostr-tools").Event[]>;
-    profiles: LRU<Observable<ProfileContent>>;
-    getProfile(pubkey: string): Observable<ProfileContent>;
+    profiles: LRU<Observable<ProfileContent | undefined>>;
+    getProfile(pubkey: string): Observable<ProfileContent | undefined>;
     reactions: LRU<Observable<import("nostr-tools").Event[]>>;
     getReactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
     mailboxes: LRU<Observable<{
         inboxes: Set<string>;
         outboxes: Set<string>;
-    }>>;
+    } | undefined>>;
     getMailboxes(pubkey: string): Observable<{
         inboxes: Set<string>;
         outboxes: Set<string>;
-    }>;
+    } | undefined>;
 }

package/dist/query-store/index.js

@@ -1,10 +1,10 @@
-import { LRU } from "tiny-lru";
 import { kinds } from "nostr-tools";
 import stringify from "json-stringify-deterministic";
 import { stateful } from "../observable/stateful.js";
 import { getProfileContent } from "../helpers/profile.js";
 import { getEventUID, getReplaceableUID, isReplaceable } from "../helpers/event.js";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
+import { LRU } from "../utils/lru.js";
 export class QueryStore {
     store;
     constructor(store) {
@@ -33,7 +33,7 @@ export class QueryStore {
     profiles = new LRU();
     getProfile(pubkey) {
         if (!this.profiles.has(pubkey)) {
-            const observable = stateful(this.getReplaceable(kinds.Metadata, pubkey).map((event) => getProfileContent(event)));
+            const observable = stateful(this.getReplaceable(kinds.Metadata, pubkey).map((event) => event && getProfileContent(event)));
             this.profiles.set(pubkey, observable);
         }
         return this.profiles.get(pubkey);
@@ -60,10 +60,10 @@ export class QueryStore {
     mailboxes = new LRU();
     getMailboxes(pubkey) {
         if (!this.mailboxes.has(pubkey)) {
-            const observable = stateful(this.getReplaceable(kinds.RelayList, pubkey).map((event) => ({
+            const observable = stateful(this.getReplaceable(kinds.RelayList, pubkey).map((event) => event && {
                 inboxes: getInboxes(event),
                 outboxes: getOutboxes(event),
-            })));
+            }));
             this.mailboxes.set(pubkey, observable);
         }
         return this.mailboxes.get(pubkey);

package/dist/utils/lru.d.ts

@@ -0,0 +1,32 @@
+type Item<T> = {
+    key: string;
+    prev: Item<T> | null;
+    value: T;
+    next: Item<T> | null;
+    expiry: number;
+};
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export declare class LRU<T extends unknown> {
+    first: Item<T> | null;
+    items: Record<string, Item<T>>;
+    last: Item<T> | null;
+    max: number;
+    resetTtl: boolean;
+    size: number;
+    ttl: number;
+    constructor(max?: number, ttl?: number, resetTtl?: boolean);
+    clear(): this;
+    delete(key: string): this;
+    entries(keys?: string[]): (string | T | undefined)[][];
+    evict(bypass?: boolean): this;
+    expiresAt(key: string): number | undefined;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    keys(): string[];
+    set(key: string, value: T, bypass?: boolean, resetTtl?: boolean): this;
+    values(keys?: string[]): NonNullable<T>[];
+}
+export {};

package/dist/utils/lru.js

@@ -0,0 +1,148 @@
+/**
+ * Copied from tiny-lru and modified to support typescript
+ * @see https://github.com/avoidwork/tiny-lru/blob/master/src/lru.js
+ */
+export class LRU {
+    first = null;
+    items = Object.create(null);
+    last = null;
+    max;
+    resetTtl;
+    size;
+    ttl;
+    constructor(max = 0, ttl = 0, resetTtl = false) {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.max = max;
+        this.resetTtl = resetTtl;
+        this.size = 0;
+        this.ttl = ttl;
+    }
+    clear() {
+        this.first = null;
+        this.items = Object.create(null);
+        this.last = null;
+        this.size = 0;
+        return this;
+    }
+    delete(key) {
+        if (this.has(key)) {
+            const item = this.items[key];
+            delete this.items[key];
+            this.size--;
+            if (item.prev !== null) {
+                item.prev.next = item.next;
+            }
+            if (item.next !== null) {
+                item.next.prev = item.prev;
+            }
+            if (this.first === item) {
+                this.first = item.next;
+            }
+            if (this.last === item) {
+                this.last = item.prev;
+            }
+        }
+        return this;
+    }
+    entries(keys = this.keys()) {
+        return keys.map((key) => [key, this.get(key)]);
+    }
+    evict(bypass = false) {
+        if (bypass || this.size > 0) {
+            const item = this.first;
+            delete this.items[item.key];
+            if (--this.size === 0) {
+                this.first = null;
+                this.last = null;
+            }
+            else {
+                this.first = item.next;
+                this.first.prev = null;
+            }
+        }
+        return this;
+    }
+    expiresAt(key) {
+        let result;
+        if (this.has(key)) {
+            result = this.items[key].expiry;
+        }
+        return result;
+    }
+    get(key) {
+        let result;
+        if (this.has(key)) {
+            const item = this.items[key];
+            if (this.ttl > 0 && item.expiry <= Date.now()) {
+                this.delete(key);
+            }
+            else {
+                result = item.value;
+                this.set(key, result, true);
+            }
+        }
+        return result;
+    }
+    has(key) {
+        return key in this.items;
+    }
+    keys() {
+        const result = [];
+        let x = this.first;
+        while (x !== null) {
+            result.push(x.key);
+            x = x.next;
+        }
+        return result;
+    }
+    set(key, value, bypass = false, resetTtl = this.resetTtl) {
+        let item;
+        if (bypass || this.has(key)) {
+            item = this.items[key];
+            item.value = value;
+            if (bypass === false && resetTtl) {
+                item.expiry = this.ttl > 0 ? Date.now() + this.ttl : this.ttl;
+            }
+            if (this.last !== item) {
+                const last = this.last, next = item.next, prev = item.prev;
+                if (this.first === item) {
+                    this.first = item.next;
+                }
+                item.next = null;
+                item.prev = this.last;
+                last.next = item;
+                if (prev !== null) {
+                    prev.next = next;
+                }
+                if (next !== null) {
+                    next.prev = prev;
+                }
+            }
+        }
+        else {
+            if (this.max > 0 && this.size === this.max) {
+                this.evict(true);
+            }
+            item = this.items[key] = {
+                expiry: this.ttl > 0 ? Date.now() + this.ttl : this.ttl,
+                key: key,
+                prev: this.last,
+                next: null,
+                value,
+            };
+            if (++this.size === 1) {
+                this.first = item;
+            }
+            else {
+                this.last.next = item;
+            }
+        }
+        this.last = item;
+        return this;
+    }
+    values(keys = this.keys()) {
+        return keys.map((key) => this.get(key));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -36,11 +36,12 @@
     }
   },
   "dependencies": {
+    "@types/zen-push": "^0.1.4",
     "debug": "^4.3.7",
     "json-stringify-deterministic": "^1.0.12",
     "nanoid": "^5.0.7",
     "nostr-tools": "^2.7.2",
-    "tiny-lru": "^11.2.11"
+    "zen-push": "^0.3.1"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",