applesauce-core 0.2.0 → 0.3.0

package/README.md

@@ -1 +1,39 @@
 # applesauce-core
+
+AppleSauce Core is an interpretation layer for nostr clients, Push events into the in-memory [database](https://hzrd149.github.io/applesauce/classes/Database.html) and get nicely formatted data out with [queries](https://hzrd149.github.io/applesauce/modules/Queries)
+
+# Example
+
+```js
+import { EventStore, QueryStore } from "applesauce-core";
+import { Relay } from "nostr-tools/relay";
+
+// The EventStore handles all the events
+const eventStore = new EventStore();
+
+// The QueryStore handles queries and makes sure not to run multiple of the same query
+const queryStore = new QueryStore(eventStore);
+
+// Use nostr-tools or anything else to talk to relays
+const relay = await Relay.connect("wss://relay.example.com");
+
+const sub = relay.subscribe([{ authors: ["266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5"] }], {
+  onevent(event) {
+    eventStore.add(event);
+  },
+});
+
+// This will return an Observable<ProfileContent | undefined> of the parsed metadata
+const profile = queryStore.profile("266815e0c9210dfa324c6cba3573b14bee49da4209a9456f9484e5106cd408a5");
+
+profile.subscribe((parsed) => {
+  if (parsed) console.log(parsed);
+});
+
+// This will return an Observable<NostrEvent[]> of all kind 1 events sorted by created_at
+const timeline = queryStore.timeline({ kinds: [1] });
+
+timeline.subscribe((events) => {
+  console.log(events);
+});
+```

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

@@ -14,7 +14,9 @@ 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 | undefined>;
+    event(uid: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind: number, pubkey: string, d?: 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

@@ -1,7 +1,7 @@
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import Observable from "zen-observable";
 import { Database } from "./database.js";
-import { getEventUID } from "../helpers/event.js";
+import { getEventUID, getReplaceableUID } from "../helpers/event.js";
 import { matchFilters } from "../helpers/filter.js";
 import { addSeenRelay } from "../helpers/relays.js";
 export class EventStore {
@@ -34,7 +34,7 @@ export class EventStore {
         return this.events.getReplaceable(kind, pubkey, d);
     }
     /** Creates an observable that updates a single event */
-    single(uid) {
+    event(uid) {
         return new Observable((observer) => {
             let current = this.events.getEvent(uid);
             if (current) {
@@ -71,6 +71,10 @@ export class EventStore {
             };
         });
     }
+    /** Creates an observable that updates a single replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.event(getReplaceableUID(kind, pubkey, d));
+    }
     /** Creates an observable that streams all events that match the filter */
     stream(filters) {
         return new Observable((observer) => {

package/dist/helpers/channel.d.ts

@@ -0,0 +1,15 @@
+import { nip19, NostrEvent } from "nostr-tools";
+import { ChannelMetadata } from "nostr-tools/nip28";
+export declare const ChannelMetadataSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ChannelMetadataSymbol]?: ChannelMetadataContent;
+    }
+}
+export type ChannelMetadataContent = ChannelMetadata & {
+    relays?: string[];
+};
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export declare function getChannelMetadataContent(channel: NostrEvent): ChannelMetadataContent;
+/** gets the EventPointer for a channel message or metadata event */
+export declare function getChannelPointer(event: NostrEvent): nip19.EventPointer | undefined;

package/dist/helpers/channel.js

@@ -0,0 +1,27 @@
+export const ChannelMetadataSymbol = Symbol.for("channel-metadata");
+function parseChannelMetadataContent(channel) {
+    const metadata = JSON.parse(channel.content);
+    if (metadata.name === undefined)
+        throw new Error("Missing name");
+    if (metadata.about === undefined)
+        throw new Error("Missing about");
+    if (metadata.picture === undefined)
+        throw new Error("Missing picture");
+    if (metadata.relays && !Array.isArray(metadata.relays))
+        throw new Error("Invalid relays");
+    return metadata;
+}
+/** Gets the parsed metadata on a channel creation or channel metadata event */
+export function getChannelMetadataContent(channel) {
+    let metadata = channel[ChannelMetadataSymbol];
+    if (!metadata)
+        metadata = channel[ChannelMetadataSymbol] = parseChannelMetadataContent(channel);
+    return metadata;
+}
+/** gets the EventPointer for a channel message or metadata event */
+export function getChannelPointer(event) {
+    const tag = event.tags.find((t) => t[0] === "e" && t[1]);
+    if (!tag)
+        return undefined;
+    return tag[2] ? { id: tag[1], relays: [tag[2]] } : { id: tag[1] };
+}

package/dist/helpers/event.d.ts

@@ -1,4 +1,12 @@
 import { NostrEvent } from "nostr-tools";
+export declare const EventUIDSymbol: unique symbol;
+export declare const EventIndexableTagsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [EventUIDSymbol]?: string;
+        [EventIndexableTagsSymbol]?: Set<string>;
+    }
+}
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )

package/dist/helpers/event.js

@@ -1,6 +1,7 @@
 import { kinds } from "nostr-tools";
 import { INDEXABLE_TAGS } from "../event-store/common.js";
-import { EventIndexableTags, EventUID } from "./symbols.js";
+export const EventUIDSymbol = Symbol.for("event-uid");
+export const EventIndexableTagsSymbol = Symbol.for("indexable-tags");
 /**
  * Returns if a kind is replaceable ( 10000 <= n < 20000 || n == 0 || n == 3 )
  * or parameterized replaceable ( 30000 <= n < 40000 )
@@ -10,29 +11,29 @@ export function isReplaceable(kind) {
 }
 /** returns the events Unique ID */
 export function getEventUID(event) {
-    if (!event[EventUID]) {
+    if (!event[EventUIDSymbol]) {
         if (isReplaceable(event.kind)) {
             const d = event.tags.find((t) => t[0] === "d")?.[1];
-            event[EventUID] = getReplaceableUID(event.kind, event.pubkey, d);
+            event[EventUIDSymbol] = getReplaceableUID(event.kind, event.pubkey, d);
         }
         else {
-            event[EventUID] = event.id;
+            event[EventUIDSymbol] = event.id;
         }
     }
-    return event[EventUID];
+    return event[EventUIDSymbol];
 }
 export function getReplaceableUID(kind, pubkey, d) {
     return d ? `${kind}:${pubkey}:${d}` : `${kind}:${pubkey}`;
 }
 export function getIndexableTags(event) {
-    if (!event[EventIndexableTags]) {
+    if (!event[EventIndexableTagsSymbol]) {
         const tags = new Set();
         for (const tag of event.tags) {
             if (tag[0] && INDEXABLE_TAGS.has(tag[0]) && tag[1]) {
                 tags.add(tag[0] + ":" + tag[1]);
             }
         }
-        event[EventIndexableTags] = tags;
+        event[EventIndexableTagsSymbol] = tags;
     }
-    return event[EventIndexableTags];
+    return event[EventIndexableTagsSymbol];
 }

package/dist/helpers/index.d.ts

@@ -3,4 +3,3 @@ 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

@@ -3,4 +3,3 @@ 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/json.d.ts

@@ -0,0 +1 @@
+export declare function safeParse<T extends unknown = any>(str: string): T | undefined;

package/dist/helpers/json.js

@@ -0,0 +1,8 @@
+export function safeParse(str) {
+    try {
+        return JSON.parse(str);
+    }
+    catch (error) {
+        return undefined;
+    }
+}

package/dist/helpers/mailboxes.d.ts

@@ -1,9 +1,17 @@
 import { NostrEvent } from "nostr-tools";
+export declare const MailboxesInboxesSymbol: unique symbol;
+export declare const MailboxesOutboxesSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MailboxesInboxesSymbol]?: Set<string>;
+        [MailboxesOutboxesSymbol]?: Set<string>;
+    }
+}
 /**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxes} symbol
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} 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
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
  */
 export declare function getOutboxes(event: NostrEvent): Set<string>;

package/dist/helpers/mailboxes.js

@@ -1,10 +1,11 @@
 import { safeRelayUrl } from "./relays.js";
-import { MailboxesInboxes, MailboxesOutboxes } from "./symbols.js";
+export const MailboxesInboxesSymbol = Symbol.for("mailboxes-inboxes");
+export const MailboxesOutboxesSymbol = Symbol.for("mailboxes-outboxes");
 /**
- * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxes} symbol
+ * Parses a 10002 event and stores the inboxes in the event using the {@link MailboxesInboxesSymbol} symbol
  */
 export function getInboxes(event) {
-    if (!event[MailboxesInboxes]) {
+    if (!event[MailboxesInboxesSymbol]) {
         const inboxes = new Set();
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "read" || tag[2] === undefined)) {
@@ -13,15 +14,15 @@ export function getInboxes(event) {
                     inboxes.add(url);
             }
         }
-        event[MailboxesInboxes] = inboxes;
+        event[MailboxesInboxesSymbol] = inboxes;
     }
-    return event[MailboxesInboxes];
+    return event[MailboxesInboxesSymbol];
 }
 /**
- * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxes} symbol
+ * Parses a 10002 event and stores the outboxes in the event using the {@link MailboxesOutboxesSymbol} symbol
  */
 export function getOutboxes(event) {
-    if (!event[MailboxesOutboxes]) {
+    if (!event[MailboxesOutboxesSymbol]) {
         const outboxes = new Set();
         for (const tag of event.tags) {
             if (tag[0] === "r" && tag[1] && (tag[2] === "write" || tag[2] === undefined)) {
@@ -30,7 +31,7 @@ export function getOutboxes(event) {
                     outboxes.add(url);
             }
         }
-        event[MailboxesOutboxes] = outboxes;
+        event[MailboxesOutboxesSymbol] = outboxes;
     }
-    return event[MailboxesOutboxes];
+    return event[MailboxesOutboxesSymbol];
 }

package/dist/helpers/mailboxes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/mailboxes.test.js

@@ -0,0 +1,80 @@
+import { getInboxes, getOutboxes } from "./mailboxes.js";
+const emptyEvent = {
+    kind: 10002,
+    content: "",
+    tags: [],
+    created_at: 0,
+    sig: "",
+    id: "",
+    pubkey: "",
+};
+describe("Mailboxes", () => {
+    describe("getInboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getInboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://inbox.com/", "read"]],
+            }))).toIncludeAllMembers(["wss://inbox.com/"]);
+        });
+    });
+    describe("getOutboxes", () => {
+        test("should transform urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("should remove bad urls", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "bad://inbox.com"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "something that is not a url"]],
+            }))).toBeArrayOfSize(0);
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com,wss://inbox.org"]],
+            }))).toBeArrayOfSize(0);
+        });
+        test("without marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+        test("with marker", () => {
+            expect(Array.from(getOutboxes({
+                ...emptyEvent,
+                tags: [["r", "wss://outbox.com/", "write"]],
+            }))).toIncludeAllMembers(["wss://outbox.com/"]);
+        });
+    });
+});

package/dist/helpers/mute.d.ts

@@ -0,0 +1,21 @@
+import { NostrEvent } from "nostr-tools";
+export declare const MutePubkeysSymbol: unique symbol;
+export declare const MuteThreadsSymbol: unique symbol;
+export declare const MuteHashtagsSymbol: unique symbol;
+export declare const MuteWordsSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [MutePubkeysSymbol]?: Set<string>;
+        [MuteThreadsSymbol]?: Set<string>;
+        [MuteHashtagsSymbol]?: Set<string>;
+        [MuteWordsSymbol]?: Set<string>;
+    }
+}
+/** Returns a set of muted pubkeys */
+export declare function getMutedPubkeys(mute: NostrEvent): Set<string>;
+/** Returns a set of muted threads */
+export declare function getMutedThreads(mute: NostrEvent): Set<string>;
+/** Returns a set of muted words ( lowercase ) */
+export declare function getMutedWords(mute: NostrEvent): Set<string>;
+/** Returns a set of muted hashtags ( lowercase ) */
+export declare function getMutedHashtags(mute: NostrEvent): Set<string>;

package/dist/helpers/mute.js

@@ -0,0 +1,52 @@
+export const MutePubkeysSymbol = Symbol.for("mute-pubkeys");
+export const MuteThreadsSymbol = Symbol.for("mute-threads");
+export const MuteHashtagsSymbol = Symbol.for("mute-hashtags");
+export const MuteWordsSymbol = Symbol.for("mute-words");
+/** Returns a set of muted pubkeys */
+export function getMutedPubkeys(mute) {
+    let pubkeys = mute[MutePubkeysSymbol];
+    if (!pubkeys) {
+        pubkeys = mute[MutePubkeysSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "p" && tag[1])
+                pubkeys.add(tag[1]);
+        }
+    }
+    return pubkeys;
+}
+/** Returns a set of muted threads */
+export function getMutedThreads(mute) {
+    let threads = mute[MuteThreadsSymbol];
+    if (!threads) {
+        threads = mute[MuteThreadsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "e" && tag[1])
+                threads.add(tag[1]);
+        }
+    }
+    return threads;
+}
+/** Returns a set of muted words ( lowercase ) */
+export function getMutedWords(mute) {
+    let words = mute[MuteWordsSymbol];
+    if (!words) {
+        words = mute[MuteWordsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "word" && tag[1])
+                words.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return words;
+}
+/** Returns a set of muted hashtags ( lowercase ) */
+export function getMutedHashtags(mute) {
+    let hashtags = mute[MuteHashtagsSymbol];
+    if (!hashtags) {
+        hashtags = mute[MuteHashtagsSymbol] = new Set();
+        for (const tag of mute.tags) {
+            if (tag[0] === "t" && tag[1])
+                hashtags.add(tag[1].toLocaleLowerCase());
+        }
+    }
+    return hashtags;
+}

package/dist/helpers/profile.d.ts

@@ -1,4 +1,10 @@
 import { NostrEvent } from "nostr-tools";
+export declare const ProfileContentSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [ProfileContentSymbol]?: ProfileContent | Error;
+    }
+}
 export type ProfileContent = {
     name?: string;
     display_name?: string;

package/dist/helpers/profile.js

@@ -1,17 +1,17 @@
-import { ProfileContent } from "./symbols.js";
+export const ProfileContentSymbol = Symbol.for("profile-content");
 export function getProfileContent(event, quite = false) {
-    let cached = event[ProfileContent];
+    let cached = event[ProfileContentSymbol];
     if (!cached) {
         try {
             const profile = JSON.parse(event.content);
             // ensure nip05 is a string
             if (profile.nip05 && typeof profile.nip05 !== "string")
                 profile.nip05 = String(profile.nip05);
-            cached = event[ProfileContent] = profile;
+            cached = event[ProfileContentSymbol] = profile;
         }
         catch (e) {
             if (e instanceof Error)
-                cached = event[ProfileContent] = e;
+                cached = event[ProfileContentSymbol] = e;
         }
     }
     if (cached === undefined) {

package/dist/helpers/relays.d.ts

@@ -1,4 +1,10 @@
 import { NostrEvent } from "nostr-tools";
+export declare const SeenRelaysSymbol: unique symbol;
+declare module "nostr-tools" {
+    interface Event {
+        [SeenRelaysSymbol]?: Set<string>;
+    }
+}
 export declare function addSeenRelay(event: NostrEvent, relay: string): Set<string>;
 export declare function getSeenRelays(event: NostrEvent): Set<string> | undefined;
 export declare function validateRelayURL(relay: string | URL): URL;

package/dist/helpers/relays.js

@@ -1,12 +1,13 @@
-import { FromRelays } from "./symbols.js";
+export const SeenRelaysSymbol = Symbol.for("seen-relays");
+// Seen relays
 export function addSeenRelay(event, relay) {
-    if (!event[FromRelays])
-        event[FromRelays] = new Set();
-    event[FromRelays].add(relay);
-    return event[FromRelays];
+    if (!event[SeenRelaysSymbol])
+        event[SeenRelaysSymbol] = new Set();
+    event[SeenRelaysSymbol].add(relay);
+    return event[SeenRelaysSymbol];
 }
 export function getSeenRelays(event) {
-    return event[FromRelays];
+    return event[SeenRelaysSymbol];
 }
 // Relay URLs
 export function validateRelayURL(relay) {

package/dist/promise/index.d.ts

@@ -1 +1 @@
-export * from './deferred.js';
+export * from "./deferred.js";

package/dist/promise/index.js

@@ -1 +1 @@
-export * from './deferred.js';
+export * from "./deferred.js";

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

@@ -1,26 +1,44 @@
 import Observable from "zen-observable";
 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";
+import * as Queries from "./queries/index.js";
+export type Query<T extends unknown> = {
+    key: string;
+    run: (events: EventStore, store: QueryStore) => Observable<T>;
+};
+export type QueryConstructor<T extends unknown, Args extends Array<any>> = (...args: Args) => Query<T>;
 export declare class QueryStore {
+    static Queries: typeof Queries;
     store: EventStore;
     constructor(store: EventStore);
-    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 | 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<{
+    queries: LRU<Observable<any>>;
+    /** Creates a cached query */
+    runQuery<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
+        key: string;
+        run: (events: EventStore, store: QueryStore) => Observable<T>;
+    }): (...args: Args) => Observable<T>;
+    /** Returns a single event */
+    event(id: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns the latest version of a replaceable event */
+    replaceable(kind: number, pubkey: string, d?: string): Observable<import("nostr-tools").Event | undefined>;
+    /** Returns an array of events that match the filter */
+    timeline(filters: Filter | Filter[]): Observable<import("nostr-tools").Event[]>;
+    /** Returns the parsed profile (0) for a pubkey */
+    profile(pubkey: string): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
+    /** Returns all reactions for an event (supports replaceable events) */
+    reactions(event: NostrEvent): Observable<import("nostr-tools").Event[]>;
+    /** Returns the parsed relay list (10002) for the pubkey */
+    mailboxes(pubkey: string): Observable<{
         inboxes: Set<string>;
         outboxes: Set<string>;
     } | undefined>;
+    /** Returns the parsed mute list for the pubkey */
+    mute(pubkey: string): Observable<{
+        words: Set<string>;
+        pubkeys: Set<string>;
+        threads: Set<string>;
+        hashtags: Set<string>;
+    } | undefined>;
 }
+export { Queries };

package/dist/query-store/index.js

@@ -1,71 +1,53 @@
-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";
+import * as Queries from "./queries/index.js";
 export class QueryStore {
+    static Queries = Queries;
     store;
     constructor(store) {
         this.store = store;
     }
-    singleEvents = new LRU();
-    getEvent(id) {
-        if (!this.singleEvents.has(id)) {
-            const observable = stateful(this.store.single(id));
-            this.singleEvents.set(id, observable);
-        }
-        return this.singleEvents.get(id);
+    queries = new LRU();
+    /** Creates a cached query */
+    runQuery(queryConstructor) {
+        return (...args) => {
+            const query = queryConstructor(...args);
+            const key = `${queryConstructor.name}|${query.key}`;
+            if (!this.queries.has(key)) {
+                const observable = stateful(query.run(this.store, this));
+                this.queries.set(key, observable);
+                return observable;
+            }
+            return this.queries.get(key);
+        };
     }
-    getReplaceable(kind, pubkey, d) {
-        return this.getEvent(getReplaceableUID(kind, pubkey, d));
+    /** Returns a single event */
+    event(id) {
+        return this.runQuery(Queries.SingleEventQuery)(id);
     }
-    timelines = new LRU();
-    getTimeline(filters) {
-        const key = stringify(filters);
-        if (!this.singleEvents.has(key)) {
-            const observable = stateful(this.store.timeline(filters));
-            this.timelines.set(key, observable);
-        }
-        return this.timelines.get(key);
+    /** Returns the latest version of a replaceable event */
+    replaceable(kind, pubkey, d) {
+        return this.runQuery(Queries.ReplaceableQuery)(kind, pubkey, d);
     }
-    profiles = new LRU();
-    getProfile(pubkey) {
-        if (!this.profiles.has(pubkey)) {
-            const observable = stateful(this.getReplaceable(kinds.Metadata, pubkey).map((event) => event && getProfileContent(event)));
-            this.profiles.set(pubkey, observable);
-        }
-        return this.profiles.get(pubkey);
+    /** Returns an array of events that match the filter */
+    timeline(filters) {
+        return this.runQuery(Queries.TimelineQuery)(filters);
     }
-    reactions = new LRU();
-    getReactions(event) {
-        const uid = getEventUID(event);
-        if (!this.reactions.has(uid)) {
-            const observable = this.getTimeline(isReplaceable(event.kind)
-                ? [
-                    { kinds: [kinds.Reaction], "#e": [event.id] },
-                    { kinds: [kinds.Reaction], "#a": [uid] },
-                ]
-                : [
-                    {
-                        kinds: [kinds.Reaction],
-                        "#e": [event.id],
-                    },
-                ]);
-            this.reactions.set(uid, observable);
-        }
-        return this.reactions.get(uid);
+    /** Returns the parsed profile (0) for a pubkey */
+    profile(pubkey) {
+        return this.runQuery(Queries.ProfileQuery)(pubkey);
     }
-    mailboxes = new LRU();
-    getMailboxes(pubkey) {
-        if (!this.mailboxes.has(pubkey)) {
-            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);
+    /** Returns all reactions for an event (supports replaceable events) */
+    reactions(event) {
+        return this.runQuery(Queries.ReactionsQuery)(event);
+    }
+    /** Returns the parsed relay list (10002) for the pubkey */
+    mailboxes(pubkey) {
+        return this.runQuery(Queries.MailboxesQuery)(pubkey);
+    }
+    /** Returns the parsed mute list for the pubkey */
+    mute(pubkey) {
+        return this.runQuery(Queries.UserMuteQuery)(pubkey);
     }
 }
+export { Queries };

package/dist/query-store/queries/channel.d.ts

@@ -0,0 +1,11 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../index.js";
+import { ChannelMetadataContent } from "../../helpers/channel.js";
+/** Creates a query that returns the latest parsed metadata */
+export declare function ChannelMetadataQuery(channel: NostrEvent): Query<ChannelMetadataContent | undefined>;
+/** Creates a query that returns a map of hidden messages Map<id, reason> */
+export declare function ChannelHiddenQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** Creates a query that returns a map of muted users Map<pubkey, reason> */
+export declare function ChannelMutedQuery(channel: NostrEvent, authors?: string[]): Query<Map<string, string>>;
+/** Creates a query that returns all messages in a channel */
+export declare function ChannelMessagesQuery(channel: NostrEvent): Query<NostrEvent[]>;

package/dist/query-store/queries/channel.js

@@ -0,0 +1,72 @@
+import { kinds } from "nostr-tools";
+import { getChannelMetadataContent } from "../../helpers/channel.js";
+import { safeParse } from "../../helpers/json.js";
+/** Creates a query that returns the latest parsed metadata */
+export function ChannelMetadataQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const filters = [
+                { ids: [channel.id] },
+                { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+            ];
+            let latest = channel;
+            return events.stream(filters).map((event) => {
+                try {
+                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                        latest = event;
+                    }
+                    return getChannelMetadataContent(latest);
+                }
+                catch (error) {
+                    return undefined;
+                }
+            });
+        },
+    };
+}
+/** Creates a query that returns a map of hidden messages Map<id, reason> */
+export function ChannelHiddenQuery(channel, authors = []) {
+    return {
+        key: channel.id,
+        run: (events) => {
+            const hidden = new Map();
+            return events
+                .stream([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "e" && tag[1])
+                        hidden.set(tag[1], reason ?? "");
+                }
+                return hidden;
+            });
+        },
+    };
+}
+/** Creates a query that returns a map of muted users Map<pubkey, reason> */
+export function ChannelMutedQuery(channel, authors = []) {
+    return {
+        key: channel.id + authors.join(","),
+        run: (events) => {
+            const muted = new Map();
+            return events
+                .stream([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+                .map((event) => {
+                const reason = safeParse(event.content)?.reason;
+                for (const tag of event.tags) {
+                    if (tag[0] === "p" && tag[1])
+                        muted.set(tag[1], reason ?? "");
+                }
+                return muted;
+            });
+        },
+    };
+}
+/** Creates a query that returns all messages in a channel */
+export function ChannelMessagesQuery(channel) {
+    return {
+        key: channel.id,
+        run: (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]),
+    };
+}

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

@@ -0,0 +1,6 @@
+export * from "./simple.js";
+export * from "./profile.js";
+export * from "./mailboxes.js";
+export * from "./reactions.js";
+export * from "./channel.js";
+export * from "./mute.js";

package/dist/query-store/queries/index.js

@@ -0,0 +1,6 @@
+export * from "./simple.js";
+export * from "./profile.js";
+export * from "./mailboxes.js";
+export * from "./reactions.js";
+export * from "./channel.js";
+export * from "./mute.js";

package/dist/query-store/queries/mailboxes.d.ts

@@ -0,0 +1,5 @@
+import { Query } from "../index.js";
+export declare function MailboxesQuery(pubkey: string): Query<{
+    inboxes: Set<string>;
+    outboxes: Set<string>;
+} | undefined>;

package/dist/query-store/queries/mailboxes.js

@@ -0,0 +1,11 @@
+import { kinds } from "nostr-tools";
+import { getInboxes, getOutboxes } from "../../helpers/mailboxes.js";
+export function MailboxesQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => events.replaceable(kinds.RelayList, pubkey).map((event) => event && {
+            inboxes: getInboxes(event),
+            outboxes: getOutboxes(event),
+        }),
+    };
+}

package/dist/query-store/queries/mute.d.ts

@@ -0,0 +1,7 @@
+import { Query } from "../index.js";
+export declare function UserMuteQuery(pubkey: string): Query<{
+    words: Set<string>;
+    pubkeys: Set<string>;
+    threads: Set<string>;
+    hashtags: Set<string>;
+} | undefined>;

package/dist/query-store/queries/mute.js

@@ -0,0 +1,16 @@
+import { kinds } from "nostr-tools";
+import { getMutedHashtags, getMutedPubkeys, getMutedThreads, getMutedWords } from "../../helpers/mute.js";
+export function UserMuteQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (store) => store.replaceable(kinds.Mutelist, pubkey).map((event) => {
+            if (!event)
+                return;
+            const pubkeys = getMutedPubkeys(event);
+            const threads = getMutedThreads(event);
+            const hashtags = getMutedHashtags(event);
+            const words = getMutedWords(event);
+            return { pubkeys, threads, hashtags, words };
+        }),
+    };
+}

package/dist/query-store/queries/profile.d.ts

@@ -0,0 +1,3 @@
+import { ProfileContent } from "../../helpers/profile.js";
+import { Query } from "../index.js";
+export declare function ProfileQuery(pubkey: string): Query<ProfileContent | undefined>;

package/dist/query-store/queries/profile.js

@@ -0,0 +1,10 @@
+import { kinds } from "nostr-tools";
+import { getProfileContent } from "../../helpers/profile.js";
+export function ProfileQuery(pubkey) {
+    return {
+        key: pubkey,
+        run: (events) => {
+            return events.replaceable(kinds.Metadata, pubkey).map((event) => event && getProfileContent(event));
+        },
+    };
+}

package/dist/query-store/queries/reactions.d.ts

@@ -0,0 +1,4 @@
+import { NostrEvent } from "nostr-tools";
+import { Query } from "../index.js";
+/** Creates a query that returns all reactions to an event (supports replaceable events) */
+export declare function ReactionsQuery(event: NostrEvent): Query<NostrEvent[]>;

package/dist/query-store/queries/reactions.js

@@ -0,0 +1,19 @@
+import { kinds } from "nostr-tools";
+import { getEventUID, isReplaceable } from "../../helpers/event.js";
+/** Creates a query that returns all reactions to an event (supports replaceable events) */
+export function ReactionsQuery(event) {
+    return {
+        key: getEventUID(event),
+        run: (events) => events.timeline(isReplaceable(event.kind)
+            ? [
+                { kinds: [kinds.Reaction], "#e": [event.id] },
+                { kinds: [kinds.Reaction], "#a": [getEventUID(event)] },
+            ]
+            : [
+                {
+                    kinds: [kinds.Reaction],
+                    "#e": [event.id],
+                },
+            ]),
+    };
+}

package/dist/query-store/queries/simple.d.ts

@@ -0,0 +1,5 @@
+import { Filter, NostrEvent } from "nostr-tools";
+import { Query } from "../index.js";
+export declare function SingleEventQuery(uid: string): Query<NostrEvent | undefined>;
+export declare function ReplaceableQuery(kind: number, pubkey: string, d?: string): Query<NostrEvent | undefined>;
+export declare function TimelineQuery(filters: Filter | Filter[]): Query<NostrEvent[]>;

package/dist/query-store/queries/simple.js

@@ -0,0 +1,20 @@
+import stringify from "json-stringify-deterministic";
+import { getReplaceableUID } from "../../helpers/event.js";
+export function SingleEventQuery(uid) {
+    return {
+        key: uid,
+        run: (events) => events.event(uid),
+    };
+}
+export function ReplaceableQuery(kind, pubkey, d) {
+    return {
+        key: getReplaceableUID(kind, pubkey, d),
+        run: (events) => events.replaceable(kind, pubkey, d),
+    };
+}
+export function TimelineQuery(filters) {
+    return {
+        key: stringify(filters),
+        run: (events) => events.timeline(Array.isArray(filters) ? filters : [filters]),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",
@@ -44,11 +44,26 @@
     "zen-push": "^0.3.1"
   },
   "devDependencies": {
+    "@jest/globals": "^29.7.0",
     "@types/debug": "^4.1.12",
+    "@types/jest": "^29.5.13",
     "@types/zen-observable": "^0.8.7",
+    "jest": "^29.7.0",
+    "jest-extended": "^4.0.2",
     "zen-observable": "^0.10.0"
   },
+  "jest": {
+    "roots": [
+      "dist"
+    ],
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ]
+  },
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "watch:build": "tsc --watch > /dev/null",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "watch:test": "(trap 'kill 0' SIGINT; pnpm run build -w > /dev/null & pnpm run test --watch)"
   }
 }

package/dist/helpers/symbols.d.ts

@@ -1,17 +0,0 @@
-import { ProfileContent as TProfileContent } from "./profile.js";
-export declare const EventUID: unique symbol;
-export declare const EventIndexableTags: unique symbol;
-export declare const MailboxesInboxes: unique symbol;
-export declare const MailboxesOutboxes: unique symbol;
-export declare const ProfileContent: unique symbol;
-export declare const FromRelays: unique symbol;
-declare module "nostr-tools" {
-    interface Event {
-        [EventUID]?: string;
-        [MailboxesInboxes]?: Set<string>;
-        [MailboxesOutboxes]?: Set<string>;
-        [ProfileContent]?: TProfileContent | Error;
-        [EventIndexableTags]?: Set<string>;
-        [FromRelays]?: Set<string>;
-    }
-}

package/dist/helpers/symbols.js

@@ -1,10 +0,0 @@
-// event
-export const EventUID = Symbol.for("event-uid");
-export const EventIndexableTags = Symbol.for("indexable-tags");
-// mailboxes
-export const MailboxesInboxes = Symbol.for("mailboxes-inboxes");
-export const MailboxesOutboxes = Symbol.for("mailboxes-outboxes");
-// profile
-export const ProfileContent = Symbol.for("profile-content");
-// event relays
-export const FromRelays = Symbol.for("from-relays");