applesauce-core 4.0.0 → 4.2.0

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

@@ -96,6 +96,8 @@ export declare class AsyncEventStore extends AsyncEventStore_base implements IAs
     add(event: NostrEvent, fromRelay?: string): Promise<NostrEvent | null>;
     /** Removes an event from the store and updates subscriptions */
     remove(event: string | NostrEvent): Promise<boolean>;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): Promise<number>;
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): Promise<void>;
     /** Check if the store has an event by id */

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

@@ -243,6 +243,21 @@ export class AsyncEventStore extends EventStoreModelMixin(class {
         }
         return removed;
     }
+    /** Remove multiple events that match the given filters */
+    async removeByFilters(filters) {
+        // Get events that will be removed for notification
+        const eventsToRemove = await this.getByFilters(filters);
+        // Remove from memory if available
+        if (this.memory)
+            this.memory.removeByFilters(filters);
+        // Remove from database
+        const removedCount = await this.database.removeByFilters(filters);
+        // Notify subscriptions for each removed event
+        for (const event of eventsToRemove) {
+            this.remove$.next(event);
+        }
+        return removedCount;
+    }
     /** Add an event to the store and notifies all subscribes it has updated */
     async update(event) {
         // Map the event to the current instance in the database

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

@@ -33,6 +33,8 @@ export declare class EventMemory implements IEventMemory {
     add(event: NostrEvent): NostrEvent;
     /** Removes an event from the database and notifies all subscriptions */
     remove(eventOrId: string | NostrEvent): boolean;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): number;
     /** Notify the database that an event has updated */
     update(_event: NostrEvent): void;
     /** A weak map of events that are claimed by other things */

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

@@ -120,6 +120,17 @@ export class EventMemory {
         this.claims.delete(event);
         return true;
     }
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters) {
+        const eventsToRemove = this.getByFilters(filters);
+        let removedCount = 0;
+        for (const event of eventsToRemove) {
+            if (this.remove(event)) {
+                removedCount++;
+            }
+        }
+        return removedCount;
+    }
     /** Notify the database that an event has updated */
     update(_event) {
         // Do nothing

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

@@ -96,6 +96,8 @@ export declare class EventStore extends EventStore_base implements IEventStore {
     add(event: NostrEvent, fromRelay?: string): NostrEvent | null;
     /** Removes an event from the store and updates subscriptions */
     remove(event: string | NostrEvent): boolean;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): number;
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event: NostrEvent): boolean;
     /** Check if the store has an event by id */

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

@@ -247,6 +247,21 @@ export class EventStore extends EventStoreModelMixin(class {
         }
         return removed;
     }
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters) {
+        // Get events that will be removed for notification
+        const eventsToRemove = this.getByFilters(filters);
+        // Remove from memory if available
+        if (this.memory)
+            this.memory.removeByFilters(filters);
+        // Remove from database
+        const removedCount = this.database.removeByFilters(filters);
+        // Notify subscriptions for each removed event
+        for (const event of eventsToRemove) {
+            this.remove$.next(event);
+        }
+        return removedCount;
+    }
     /** Add an event to the store and notifies all subscribes it has updated */
     update(event) {
         // Map the event to the current instance in the database

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

@@ -146,6 +146,8 @@ export interface IEventDatabase extends IEventStoreRead {
     add(event: NostrEvent): NostrEvent;
     /** Remove an event from the database */
     remove(event: string | NostrEvent): boolean;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): number;
     /** Notifies the database that an event has updated */
     update?: (event: NostrEvent) => void;
 }
@@ -155,6 +157,8 @@ export interface IAsyncEventDatabase extends IAsyncEventStoreRead {
     add(event: NostrEvent): Promise<NostrEvent>;
     /** Remove an event from the database */
     remove(event: string | NostrEvent): Promise<boolean>;
+    /** Remove multiple events that match the given filters */
+    removeByFilters(filters: Filter | Filter[]): Promise<number>;
     /** Notifies the database that an event has updated */
     update?: (event: NostrEvent) => void;
 }

package/dist/helpers/article.d.ts

@@ -1,5 +1,9 @@
-import { NostrEvent } from "nostr-tools";
+import { kinds, NostrEvent } from "nostr-tools";
+import { KnownEvent } from "./index.js";
+/** Type for validated article events */
+export type ArticleEvent = KnownEvent<kinds.LongFormArticle>;
 /** Returns an articles title, if it exists */
+export declare function getArticleTitle(article: ArticleEvent): string;
 export declare function getArticleTitle(article: NostrEvent): string | undefined;
 /** Returns an articles image, if it exists */
 export declare function getArticleImage(article: NostrEvent): string | undefined;
@@ -7,3 +11,5 @@ export declare function getArticleImage(article: NostrEvent): string | undefined
 export declare function getArticleSummary(article: NostrEvent): string | undefined;
 /** Returns an articles published date, if it exists */
 export declare function getArticlePublished(article: NostrEvent): number;
+/** validates that an event is a valid article event */
+export declare function isValidArticle(article: NostrEvent): article is ArticleEvent;

package/dist/helpers/article.js

@@ -1,5 +1,5 @@
+import { kinds } from "nostr-tools";
 import { getTagValue } from "./event-tags.js";
-/** Returns an articles title, if it exists */
 export function getArticleTitle(article) {
     return getTagValue(article, "title");
 }
@@ -19,3 +19,7 @@ export function getArticlePublished(article) {
     else
         return article.created_at;
 }
+/** validates that an event is a valid article event */
+export function isValidArticle(article) {
+    return article.kind === kinds.LongFormArticle && getArticleTitle(article) !== undefined && article.content.length > 0;
+}

package/dist/helpers/pointers.d.ts

@@ -1,5 +1,7 @@
 import { AddressPointer, EventPointer, ProfilePointer, decode } from "nostr-tools/nip19";
 import { NostrEvent } from "nostr-tools";
+export type { AddressPointer, EventPointer, ProfilePointer } from "nostr-tools/nip19";
+export { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, decode as decodePointer, } from "nostr-tools/nip19";
 export type DecodeResult = ReturnType<typeof decode>;
 export type AddressPointerWithoutD = Omit<AddressPointer, "identifier"> & {
     identifier?: string;

package/dist/helpers/pointers.js

@@ -1,5 +1,7 @@
 import { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, } from "nostr-tools/nip19";
 import { getPublicKey, kinds, nip19 } from "nostr-tools";
+// export nip-19 helpers
+export { naddrEncode, neventEncode, noteEncode, nprofileEncode, npubEncode, nsecEncode, decode as decodePointer, } from "nostr-tools/nip19";
 import { getReplaceableIdentifier } from "./event.js";
 import { isAddressableKind } from "nostr-tools/kinds";
 import { isSafeRelayURL, mergeRelaySets } from "./relays.js";

package/dist/helpers/relay-selection.d.ts

@@ -1,4 +1,5 @@
-import { ProfilePointer } from "nostr-tools/nip19";
+import { ProfilePointer } from "./pointers.js";
+import { Filter } from "./filter.js";
 export type SelectOptimalRelaysOptions = {
     /** Maximum number of connections (relays) to select */
     maxConnections: number;
@@ -7,7 +8,17 @@ export type SelectOptimalRelaysOptions = {
 };
 /** Selects the optimal relays for a list of ProfilePointers */
 export declare function selectOptimalRelays(users: ProfilePointer[], { maxConnections, maxRelaysPerUser }: SelectOptimalRelaysOptions): ProfilePointer[];
+/** Sets relays for any user that has 0 relays */
+export declare function setFallbackRelays(users: ProfilePointer[], fallbacks: string[]): ProfilePointer[];
+/** Removes blacklisted relays from the user's relays */
+export declare function removeBlacklistedRelays(users: ProfilePointer[], blacklist: string[]): ProfilePointer[];
 /** A map of pubkeys by relay */
 export type OutboxMap = Record<string, ProfilePointer[]>;
-/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+/** A map of filters by relay */
+export type FilterMap = Record<string, Filter | Filter[]>;
+/** Creates an {@link OutboxMap} for an array of profile points (groups users by relay) */
 export declare function groupPubkeysByRelay(pointers: ProfilePointer[]): OutboxMap;
+/** Alias for {@link groupPubkeysByRelay} */
+export declare const createOutboxMap: typeof groupPubkeysByRelay;
+/** Creates a {@link FilterMap} for an {@link OutboxMap} */
+export declare function createFilterMap(outboxMap: OutboxMap, filter: Omit<Filter, "authors">): FilterMap;

package/dist/helpers/relay-selection.js

@@ -68,7 +68,25 @@ export function selectOptimalRelays(users, { maxConnections, maxRelaysPerUser })
             : user.relays?.filter((relay) => selection.has(relay)),
     }));
 }
-/** RxJS operator that aggregates contacts with outboxes into a relay -> pubkeys map */
+/** Sets relays for any user that has 0 relays */
+export function setFallbackRelays(users, fallbacks) {
+    return users.map((user) => {
+        if (!user.relays || user.relays.length === 0)
+            return { ...user, relays: fallbacks };
+        else
+            return user;
+    });
+}
+/** Removes blacklisted relays from the user's relays */
+export function removeBlacklistedRelays(users, blacklist) {
+    return users.map((user) => {
+        if (!user.relays || user.relays.length === 0)
+            return user;
+        else
+            return { ...user, relays: user.relays.filter((relay) => !blacklist.includes(relay)) };
+    });
+}
+/** Creates an {@link OutboxMap} for an array of profile points (groups users by relay) */
 export function groupPubkeysByRelay(pointers) {
     const outbox = {};
     for (const pointer of pointers) {
@@ -82,3 +100,12 @@ export function groupPubkeysByRelay(pointers) {
     }
     return outbox;
 }
+/** Alias for {@link groupPubkeysByRelay} */
+export const createOutboxMap = groupPubkeysByRelay;
+/** Creates a {@link FilterMap} for an {@link OutboxMap} */
+export function createFilterMap(outboxMap, filter) {
+    return Object.fromEntries(Array.from(Object.entries(outboxMap)).map(([relay, users]) => [
+        relay,
+        { authors: users.map((user) => user.pubkey), ...filter },
+    ]));
+}

package/dist/helpers/zap.d.ts

@@ -2,6 +2,8 @@ import { kinds, NostrEvent } from "nostr-tools";
 import { AddressPointer, EventPointer } from "nostr-tools/nip19";
 import { ParsedInvoice } from "./bolt11.js";
 import { KnownEvent } from "./index.js";
+/** Type for validated zap event */
+export type ZapEvent = KnownEvent<kinds.Zap>;
 export declare const ZapRequestSymbol: unique symbol;
 export declare const ZapSenderSymbol: unique symbol;
 export declare const ZapReceiverSymbol: unique symbol;
@@ -9,16 +11,16 @@ export declare const ZapInvoiceSymbol: unique symbol;
 export declare const ZapEventPointerSymbol: unique symbol;
 export declare const ZapAddressPointerSymbol: unique symbol;
 /** Returns the senders pubkey */
-export declare function getZapSender(zap: KnownEvent<kinds.Zap>): string;
+export declare function getZapSender(zap: ZapEvent): string;
 export declare function getZapSender(zap: NostrEvent): string | undefined;
 /** Gets the receivers pubkey */
-export declare function getZapRecipient(zap: KnownEvent<kinds.Zap>): string;
+export declare function getZapRecipient(zap: ZapEvent): string;
 export declare function getZapRecipient(zap: NostrEvent): string | undefined;
 /** Returns the parsed bolt11 invoice */
-export declare function getZapPayment(zap: KnownEvent<kinds.Zap>): ParsedInvoice;
+export declare function getZapPayment(zap: ZapEvent): ParsedInvoice;
 export declare function getZapPayment(zap: NostrEvent): ParsedInvoice | undefined;
 /** Returns the zap event amount in msats */
-export declare function getZapAmount(zap: KnownEvent<kinds.Zap>): number;
+export declare function getZapAmount(zap: ZapEvent): number;
 export declare function getZapAmount(zap: NostrEvent): number | undefined;
 /** Gets the AddressPointer that was zapped */
 export declare function getZapAddressPointer(zap: NostrEvent): AddressPointer | null;
@@ -27,13 +29,13 @@ export declare function getZapEventPointer(zap: NostrEvent): EventPointer | null
 /** Gets the preimage for the bolt11 invoice */
 export declare function getZapPreimage(zap: NostrEvent): string | undefined;
 /** Returns the zap request event inside the zap receipt */
-export declare function getZapRequest(zap: KnownEvent<kinds.Zap>): NostrEvent;
+export declare function getZapRequest(zap: ZapEvent): NostrEvent;
 export declare function getZapRequest(zap: NostrEvent): NostrEvent | undefined;
 /**
  * Checks if a zap event is valid (not missing fields)
  * DOES NOT validate LNURL address
  */
-export declare function isValidZap(zap?: NostrEvent): zap is KnownEvent<kinds.Zap>;
+export declare function isValidZap(zap?: NostrEvent): zap is ZapEvent;
 export type ZapSplit = {
     pubkey: string;
     percent: number;

package/dist/observable/relay-selection.d.ts

@@ -5,3 +5,7 @@ import { IEventSubscriptions } from "../event-store/interface.js";
 export declare function includeMailboxes(store: IEventSubscriptions, type?: "inbox" | "outbox"): OperatorFunction<ProfilePointer[], ProfilePointer[]>;
 /** Removes blacklisted relays from the user's relays */
 export declare function ignoreBlacklistedRelays(blacklist: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;
+/** Sets fallback relays for any user that has 0 relays */
+export declare function includeFallbackRelays(fallbacks: string[] | Observable<string[]>): MonoTypeOperatorFunction<ProfilePointer[]>;
+/** A operator calls {@link selectOptimalRelays} and filters the relays for the user */
+export declare function filterOptimalRelays(maxConnections: number | Observable<number>, maxRelaysPerUser: number | Observable<number>): MonoTypeOperatorFunction<ProfilePointer[]>;

package/dist/observable/relay-selection.js

@@ -1,6 +1,7 @@
 import { combineLatest, combineLatestWith, isObservable, map, of, pipe, switchMap, } from "rxjs";
 import { getInboxes, getOutboxes } from "../helpers/mailboxes.js";
 import { addRelayHintsToPointer } from "../helpers/pointers.js";
+import { removeBlacklistedRelays, selectOptimalRelays, setFallbackRelays } from "../helpers/relay-selection.js";
 /** RxJS operator that fetches outboxes for profile pointers from the event store */
 export function includeMailboxes(store, type = "outbox") {
     // Get the outboxes for all contacts
@@ -30,9 +31,21 @@ export function ignoreBlacklistedRelays(blacklist) {
     // Combine with the observable so it re-emits when the blacklist changes
     combineLatestWith(isObservable(blacklist) ? blacklist : of(blacklist)), 
     // Filter the relays for the user
-    map(([users, blacklist]) => users.map((user) => {
-        if (!user.relays)
-            return user;
-        return { ...user, relays: user.relays.filter((relay) => !blacklist.includes(relay)) };
-    })));
+    map(([users, blacklist]) => removeBlacklistedRelays(users, blacklist)));
+}
+/** Sets fallback relays for any user that has 0 relays */
+export function includeFallbackRelays(fallbacks) {
+    return pipe(
+    // Get the fallbacks from the observable
+    combineLatestWith(isObservable(fallbacks) ? fallbacks : of(fallbacks)), 
+    // Set the fallback relays for the users
+    map(([users, fallbacks]) => setFallbackRelays(users, fallbacks)));
+}
+/** A operator calls {@link selectOptimalRelays} and filters the relays for the user */
+export function filterOptimalRelays(maxConnections, maxRelaysPerUser) {
+    return pipe(
+    // Combine with the observable so it re-emits when the max connections and max relays per user change
+    combineLatestWith(isObservable(maxConnections) ? maxConnections : of(maxConnections), isObservable(maxRelaysPerUser) ? maxRelaysPerUser : of(maxRelaysPerUser)), 
+    // Filter the relays for the user
+    map(([users, maxConnections, maxRelaysPerUser]) => selectOptimalRelays(users, { maxConnections, maxRelaysPerUser })));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "",
   "type": "module",
   "main": "dist/index.js",