applesauce-core 0.12.1 → 1.2.0

package/dist/queries/bookmarks.d.ts

@@ -1,8 +1,8 @@
 import { Bookmarks } from "../helpers/bookmarks.js";
 import { Query } from "../query-store/index.js";
+/** A query that returns all the bookmarks of a user */
 export declare function UserBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
-export declare function UserHiddenBookmarkQuery(pubkey: string): Query<(Bookmarks & {
-    locked: false;
-}) | {
-    locked: true;
-} | undefined>;
+/** A query that returns all the public bookmarks of a user */
+export declare function UserPublicBookmarkQuery(pubkey: string): Query<Bookmarks | undefined>;
+/** A query that returns all the hidden bookmarks of a user */
+export declare function UserHiddenBookmarkQuery(pubkey: string): Query<Bookmarks | null | undefined>;

package/dist/queries/bookmarks.js

@@ -1,23 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isHiddenTagsLocked } from "../helpers/index.js";
-import { getBookmarks, getHiddenBookmarks } from "../helpers/bookmarks.js";
+import { getBookmarks, getHiddenBookmarks, getPublicBookmarks } from "../helpers/bookmarks.js";
+import { listenLatestUpdates } from "../observable/index.js";
+/** A query that returns all the bookmarks of a user */
 export function UserBookmarkQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getBookmarks(event))),
-    };
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all bookmarks
+    map((event) => event && getBookmarks(event)));
 }
+/** A query that returns all the public bookmarks of a user */
+export function UserPublicBookmarkQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicBookmarks(event)));
+}
+/** A query that returns all the hidden bookmarks of a user */
 export function UserHiddenBookmarkQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const bookmarks = getHiddenBookmarks(event);
-            if (isHiddenTagsLocked(event) || !bookmarks)
-                return { locked: true };
-            return { locked: false, ...bookmarks };
-        })),
-    };
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden bookmarks
+    map((event) => event && (getHiddenBookmarks(event) ?? null)));
 }

package/dist/queries/channels.js

@@ -4,70 +4,58 @@ import { map } from "rxjs";
 import { getChannelMetadataContent } from "../helpers/channels.js";
 /** 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
-                .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
-                .pipe(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;
-            }));
-        },
+    return (events) => {
+        const hidden = new Map();
+        return events
+            .filters([{ kinds: [kinds.ChannelHideMessage], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+            .pipe(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;
+        }));
     };
 }
 /** 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] }]),
-    };
+    return (events) => events.timeline([{ kinds: [kinds.ChannelMessage], "#e": [channel.id] }]);
 }
 /** 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.filters(filters).pipe(map((event) => {
-                try {
-                    if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
-                        latest = event;
-                    }
-                    return getChannelMetadataContent(latest);
+    return (events) => {
+        const filters = [
+            { ids: [channel.id] },
+            { kinds: [kinds.ChannelMetadata], "#e": [channel.id], authors: [channel.pubkey] },
+        ];
+        let latest = channel;
+        return events.filters(filters).pipe(map((event) => {
+            try {
+                if (event.pubkey === latest.pubkey && event.created_at > latest.created_at) {
+                    latest = event;
                 }
-                catch (error) {
-                    return undefined;
-                }
-            }));
-        },
+                return getChannelMetadataContent(latest);
+            }
+            catch (error) {
+                return undefined;
+            }
+        }));
     };
 }
 /** 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
-                .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
-                .pipe(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;
-            }));
-        },
+    return (events) => {
+        const muted = new Map();
+        return events
+            .filters([{ kinds: [kinds.ChannelMuteUser], "#e": [channel.id], authors: [channel.pubkey, ...authors] }])
+            .pipe(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;
+        }));
     };
 }

package/dist/queries/comments.js

@@ -1,14 +1,11 @@
 import { COMMENT_KIND, getEventUID } from "../helpers/index.js";
-import { isParameterizedReplaceableKind } from "nostr-tools/kinds";
+import { isAddressableKind } from "nostr-tools/kinds";
 /** Returns all NIP-22 comment replies for the event */
 export function CommentsQuery(parent) {
-    return {
-        key: `${getEventUID(parent)}-comments`,
-        run: (events) => {
-            const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
-            if (isParameterizedReplaceableKind(parent.kind))
-                filter["#a"] = [getEventUID(parent)];
-            return events.timeline(filter);
-        },
+    return (events) => {
+        const filter = { kinds: [COMMENT_KIND], "#e": [parent.id] };
+        if (isAddressableKind(parent.kind))
+            filter["#a"] = [getEventUID(parent)];
+        return events.timeline(filter);
     };
 }

package/dist/queries/contacts.d.ts

@@ -1,3 +1,8 @@
 import { ProfilePointer } from "nostr-tools/nip19";
 import { Query } from "../query-store/index.js";
-export declare function UserContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all contacts for a user */
+export declare function ContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all public contacts for a user */
+export declare function PublicContactsQuery(pubkey: string): Query<ProfilePointer[] | undefined>;
+/** A query that returns all hidden contacts for a user */
+export declare function HiddenContactsQuery(pubkey: string): Query<ProfilePointer[] | null | undefined>;

package/dist/queries/contacts.js

@@ -1,12 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { isPTag, processTags } from "../helpers/tags.js";
-import { getProfilePointerFromPTag } from "../helpers/pointers.js";
-export function UserContactsQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(kinds.Contacts, pubkey)
-            .pipe(map((event) => event && processTags(event.tags.filter(isPTag), getProfilePointerFromPTag))),
-    };
+import { getContacts, getHiddenContacts, getPublicContacts } from "../helpers/contacts.js";
+import { listenLatestUpdates } from "../observable/index.js";
+/** A query that returns all contacts for a user */
+export function ContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all contacts
+    map((e) => e && getContacts(e)));
+}
+/** A query that returns all public contacts for a user */
+export function PublicContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(map((e) => e && getPublicContacts(e)));
+}
+/** A query that returns all hidden contacts for a user */
+export function HiddenContactsQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Contacts, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden contacts
+    map((e) => e && (getHiddenContacts(e) ?? null)));
 }

package/dist/queries/index.d.ts

@@ -3,6 +3,7 @@ export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./contacts.js";
+export * from "./relays.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";

package/dist/queries/index.js

@@ -3,6 +3,7 @@ export * from "./bookmarks.js";
 export * from "./channels.js";
 export * from "./comments.js";
 export * from "./contacts.js";
+export * from "./relays.js";
 export * from "./mailboxes.js";
 export * from "./mutes.js";
 export * from "./pins.js";

package/dist/queries/mailboxes.js

@@ -3,11 +3,8 @@ import { map } from "rxjs/operators";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 /** A query that gets and parses the inbox and outbox relays for a pubkey */
 export function MailboxesQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
-            inboxes: getInboxes(event),
-            outboxes: getOutboxes(event),
-        })),
-    };
+    return (events) => events.replaceable(kinds.RelayList, pubkey).pipe(map((event) => event && {
+        inboxes: getInboxes(event),
+        outboxes: getOutboxes(event),
+    }));
 }

package/dist/queries/mutes.d.ts

@@ -1,8 +1,8 @@
 import { Mutes } from "../helpers/mutes.js";
 import { Query } from "../query-store/index.js";
-export declare function UserMuteQuery(pubkey: string): Query<Mutes | undefined>;
-export declare function UserHiddenMuteQuery(pubkey: string): Query<(Mutes & {
-    locked: false;
-}) | {
-    locked: true;
-} | undefined>;
+/** A query that returns all a users muted things */
+export declare function MuteQuery(pubkey: string): Query<Mutes | undefined>;
+/** A query that returns all a users public muted things */
+export declare function PublicMuteQuery(pubkey: string): Query<Mutes | undefined>;
+/** A query that returns all a users hidden muted things */
+export declare function HiddenMuteQuery(pubkey: string): Query<Mutes | null | undefined>;

package/dist/queries/mutes.js

@@ -1,23 +1,24 @@
 import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
-import { getHiddenMutedThings, getMutedThings } from "../helpers/mutes.js";
-import { isHiddenTagsLocked } from "../helpers/hidden-tags.js";
-export function UserMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (event) => event.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getMutedThings(event))),
-    };
+import { getHiddenMutedThings, getMutedThings, getPublicMutedThings } from "../helpers/mutes.js";
+import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+/** A query that returns all a users muted things */
+export function MuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get all muted things
+    map((event) => event && getMutedThings(event)));
 }
-export function UserHiddenMuteQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => {
-            if (!event)
-                return undefined;
-            const muted = getHiddenMutedThings(event);
-            if (isHiddenTagsLocked(event) || !muted)
-                return { locked: true };
-            return { locked: false, ...muted };
-        })),
-    };
+/** A query that returns all a users public muted things */
+export function PublicMuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(map((event) => event && getPublicMutedThings(event)));
+}
+/** A query that returns all a users hidden muted things */
+export function HiddenMuteQuery(pubkey) {
+    return (events) => events.replaceable(kinds.Mutelist, pubkey).pipe(
+    // listen for event updates (hidden tags unlocked)
+    listenLatestUpdates(events), 
+    // Get hidden muted things
+    map((event) => event && getHiddenMutedThings(event)));
 }

package/dist/queries/pins.d.ts

@@ -1,3 +1,4 @@
 import { Query } from "applesauce-core";
 import { EventPointer } from "nostr-tools/nip19";
+/** A query that returns all pinned pointers for a user */
 export declare function UserPinnedQuery(pubkey: string): Query<EventPointer[] | undefined>;

package/dist/queries/pins.js

@@ -2,11 +2,9 @@ import { kinds } from "nostr-tools";
 import { map } from "rxjs/operators";
 import { isETag, processTags } from "../helpers/tags.js";
 import { getEventPointerFromETag } from "../helpers/pointers.js";
+/** A query that returns all pinned pointers for a user */
 export function UserPinnedQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (store) => store
-            .replaceable(kinds.Pinlist, pubkey)
-            .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag))),
-    };
+    return (events) => events
+        .replaceable(kinds.Pinlist, pubkey)
+        .pipe(map((event) => event && processTags(event.tags.filter(isETag), getEventPointerFromETag)));
 }

package/dist/queries/profile.js

@@ -3,10 +3,5 @@ import { filter, map } from "rxjs/operators";
 import { getProfileContent, isValidProfile } from "../helpers/profile.js";
 /** A query that gets and parses the kind 0 metadata for a pubkey */
 export function ProfileQuery(pubkey) {
-    return {
-        key: pubkey,
-        run: (events) => {
-            return events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
-        },
-    };
+    return (events) => events.replaceable(kinds.Metadata, pubkey).pipe(filter(isValidProfile), map((event) => event && getProfileContent(event)));
 }

package/dist/queries/reactions.js

@@ -2,18 +2,15 @@ import { kinds } from "nostr-tools";
 import { getEventUID, isReplaceable } from "../helpers/event.js";
 /** 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],
-                },
-            ]),
-    };
+    return (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/queries/relays.d.ts

@@ -0,0 +1,27 @@
+import { AddressPointer } from "nostr-tools/nip19";
+import { ReadListTags } from "../helpers/lists.js";
+import { Query } from "../query-store/query-store.js";
+/**
+ * A query that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;
+/**
+ * A query that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export declare function FavoriteRelaySets(pubkey: string, type?: ReadListTags): Query<AddressPointer[] | undefined>;
+/**
+ * A query that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export declare function SearchRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;
+/**
+ * A query that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export declare function BlockedRelays(pubkey: string, type?: ReadListTags): Query<string[] | undefined>;

package/dist/queries/relays.js

@@ -0,0 +1,44 @@
+import { kinds } from "nostr-tools";
+import { identity, map } from "rxjs";
+import { FAVORITE_RELAYS_KIND, getAddressPointersFromList, getRelaysFromList } from "../helpers/lists.js";
+import { listenLatestUpdates } from "../observable/listen-latest-updates.js";
+/**
+ * A query that returns all favorite relays for a pubkey
+ * @param pubkey - The pubkey to get the favorite relays for
+ * @param type - Which types of tags to read
+ */
+export function FavoriteRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all favorite relay sets for a pubkey
+ * @param pubkey - The pubkey to get the favorite relay sets for
+ * @param type - Which types of tags to read
+ */
+export function FavoriteRelaySets(pubkey, type) {
+    return (events) => {
+        return events.replaceable(FAVORITE_RELAYS_KIND, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getAddressPointersFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all search relays for a pubkey
+ * @param pubkey - The pubkey to get the search relays for
+ * @param type - Which types of tags to read
+ */
+export function SearchRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(kinds.SearchRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}
+/**
+ * A query that returns all blocked relays for a pubkey
+ * @param pubkey - The pubkey to get the blocked relays for
+ * @param type - Which types of tags to read
+ */
+export function BlockedRelays(pubkey, type) {
+    return (events) => {
+        return events.replaceable(kinds.BlockedRelaysList, pubkey).pipe(type !== "public" ? listenLatestUpdates(events) : map(identity), map((e) => e && getRelaysFromList(e, type)));
+    };
+}

package/dist/queries/simple.js

@@ -1,38 +1,21 @@
-import hash_sum from "hash-sum";
-import { getReplaceableUID } from "../helpers/event.js";
 /** Creates a Query that returns a single event or undefined */
 export function SingleEventQuery(id) {
-    return {
-        key: id,
-        run: (events) => events.event(id),
-    };
+    return (events) => events.event(id);
 }
 /** Creates a Query that returns a multiple events in a map */
 export function MultipleEventsQuery(ids) {
-    return {
-        key: ids.join(","),
-        run: (events) => events.events(ids),
-    };
+    return (events) => events.events(ids);
 }
 /** Creates a Query returning the latest version of a replaceable event */
 export function ReplaceableQuery(kind, pubkey, d) {
-    return {
-        key: getReplaceableUID(kind, pubkey, d),
-        run: (events) => events.replaceable(kind, pubkey, d),
-    };
+    return (events) => events.replaceable(kind, pubkey, d);
 }
 /** Creates a Query that returns an array of sorted events matching the filters */
 export function TimelineQuery(filters, includeOldVersion) {
     filters = Array.isArray(filters) ? filters : [filters];
-    return {
-        key: hash_sum(filters) + (includeOldVersion ? "-history" : ""),
-        run: (events) => events.timeline(filters, includeOldVersion),
-    };
+    return (events) => events.timeline(filters, includeOldVersion);
 }
 /** Creates a Query that returns a directory of events by their UID */
 export function ReplaceableSetQuery(pointers) {
-    return {
-        key: hash_sum(pointers),
-        run: (events) => events.replaceableSet(pointers),
-    };
+    return (events) => events.replaceableSet(pointers);
 }