applesauce-core 0.0.0-next-20250729145125 → 0.0.0-next-20250808173123

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

@@ -9,6 +9,8 @@ export declare class EventStore implements IEventStore {
     database: EventSet;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
+    /** Enable this to keep expired events */
+    keepExpired: boolean;
     /**
      * A method used to verify new events before added them
      * @returns true if the event is valid, false if it should be ignored
@@ -24,21 +26,29 @@ export declare class EventStore implements IEventStore {
      * A method that will be called when an event isn't found in the store
      * @experimental
      */
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent>;
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     /**
      * A method that will be called when a replaceable event isn't found in the store
      * @experimental
      */
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent>;
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     /**
      * A method that will be called when an addressable event isn't found in the store
      * @experimental
      */
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent>;
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     constructor();
     protected deletedIds: Set<string>;
     protected deletedCoords: Map<string, number>;
     protected checkDeleted(event: string | NostrEvent): boolean;
+    protected expirations: Map<string, number>;
+    /** Adds an event to the expiration map */
+    protected addExpiration(event: NostrEvent): void;
+    protected expirationTimeout: number | null;
+    protected nextExpirationCheck: number | null;
+    protected handleExpiringEvent(event: NostrEvent): void;
+    /** Remove expired events from the store */
+    protected pruneExpired(): void;
     protected handleDeleteEvent(deleteEvent: NostrEvent): void;
     /** Copies important metadata from and identical event to another */
     static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;

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

@@ -4,9 +4,11 @@ import { EMPTY, filter, finalize, from, merge, mergeMap, ReplaySubject, share, t
 import hash_sum from "hash-sum";
 import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
 import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isReplaceable } from "../helpers/event.js";
+import { getExpirationTimestamp } from "../helpers/expiration.js";
 import { matchFilters } from "../helpers/filter.js";
 import { parseCoordinate } from "../helpers/pointers.js";
 import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { unixNow } from "../helpers/time.js";
 import { UserBlossomServersModel } from "../models/blossom.js";
 import { EventModel, EventsModel, ReplaceableModel, ReplaceableSetModel, TimelineModel } from "../models/common.js";
 import { ContactsModel } from "../models/contacts.js";
@@ -21,6 +23,8 @@ export class EventStore {
     database;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
+    /** Enable this to keep expired events */
+    keepExpired = false;
     /**
      * A method used to verify new events before added them
      * @returns true if the event is valid, false if it should be ignored
@@ -87,6 +91,46 @@ export class EventStore {
         }
         return false;
     }
+    expirations = new Map();
+    /** Adds an event to the expiration map */
+    addExpiration(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (expiration && Number.isFinite(expiration))
+            this.expirations.set(event.id, expiration);
+    }
+    expirationTimeout = null;
+    nextExpirationCheck = null;
+    handleExpiringEvent(event) {
+        const expiration = getExpirationTimestamp(event);
+        if (!expiration)
+            return;
+        // Add event to expiration map
+        this.expirations.set(event.id, expiration);
+        // Exit if the next check is already less than the next expiration
+        if (this.expirationTimeout && this.nextExpirationCheck && this.nextExpirationCheck < expiration)
+            return;
+        // Set timeout to prune expired events
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        const timeout = expiration - unixNow();
+        this.expirationTimeout = setTimeout(this.pruneExpired.bind(this), timeout * 1000 + 10);
+        this.nextExpirationCheck = expiration;
+    }
+    /** Remove expired events from the store */
+    pruneExpired() {
+        const now = unixNow();
+        for (const [id, expiration] of this.expirations) {
+            if (expiration <= now) {
+                this.expirations.delete(id);
+                this.remove(id);
+            }
+        }
+        // Cleanup timers
+        if (this.expirationTimeout)
+            clearTimeout(this.expirationTimeout);
+        this.nextExpirationCheck = null;
+        this.expirationTimeout = null;
+    }
     // handling delete events
     handleDeleteEvent(deleteEvent) {
         const ids = getDeleteIds(deleteEvent);
@@ -134,6 +178,10 @@ export class EventStore {
         // Ignore if the event was deleted
         if (this.checkDeleted(event))
             return event;
+        // Reject expired events if keepExpired is false
+        const expiration = getExpirationTimestamp(event);
+        if (this.keepExpired === false && expiration && expiration <= unixNow())
+            return null;
         // Get the replaceable identifier
         const identifier = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
         // Don't insert the event if there is already a newer version
@@ -177,6 +225,9 @@ export class EventStore {
                     return existing[0];
             }
         }
+        // Add event to expiration map
+        if (this.keepExpired === false && expiration)
+            this.handleExpiringEvent(inserted);
         return inserted;
     }
     /** Removes an event from the database and updates subscriptions */

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

@@ -84,14 +84,18 @@ export interface IEventSet extends IEventStoreRead, IEventStoreStreams, IEventSt
     events: LRU<NostrEvent>;
 }
 export interface IEventStore extends IEventStoreRead, IEventStoreStreams, IEventStoreActions, IEventStoreModels, IEventClaims {
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions: boolean;
+    /** Enable this to keep expired events */
+    keepExpired: boolean;
     filters(filters: Filter | Filter[]): Observable<NostrEvent>;
     updated(id: string | NostrEvent): Observable<NostrEvent>;
     removed(id: string): Observable<never>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
     replaceable(pointer: AddressPointerWithoutD): Observable<NostrEvent | undefined>;
-    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent>;
-    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent>;
-    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent>;
+    eventLoader?: (pointer: EventPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    replaceableLoader?: (pointer: AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
+    addressableLoader?: (pointer: AddressPointer) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
     profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
     contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
     mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;

package/dist/helpers/encrypted-content.d.ts

@@ -10,18 +10,24 @@ export interface EncryptedContentSigner {
         decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
     };
 }
-/** Various event kinds that can have encrypted content and which encryption method they use */
-export declare const EventContentEncryptionMethod: Record<number, "nip04" | "nip44">;
-/** Sets the encryption method that is used for the contents of a specific event kind */
-export declare function setEncryptedContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner): {
+export type EncryptionMethod = "nip04" | "nip44";
+/** A pair of encryption methods for encrypting and decrypting event content */
+export interface EncryptionMethods {
     encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
     decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-} | {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-};
+}
+/** Various event kinds that can have encrypted content and which encryption method they use */
+export declare const EventContentEncryptionMethod: Record<number, EncryptionMethod>;
+/** Sets the encryption method that is used for the contents of a specific event kind */
+export declare function setEncryptedContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @returns The encryption methods for the event kind
+ */
+export declare function getEncryptedContentEncryptionMethods(kind: number, signer: EncryptedContentSigner, override?: EncryptionMethod): EncryptionMethods;
 /** Checks if an event can have encrypted content */
 export declare function canHaveEncryptedContent(kind: number): boolean;
 /** Checks if an event has encrypted content */

package/dist/helpers/encrypted-content.js

@@ -13,9 +13,15 @@ export function setEncryptedContentEncryptionMethod(kind, method) {
     EventContentEncryptionMethod[kind] = method;
     return kind;
 }
-/** Returns either nip04 or nip44 encryption methods depending on event kind */
-export function getEncryptedContentEncryptionMethods(kind, signer) {
-    const method = EventContentEncryptionMethod[kind];
+/**
+ * Returns either nip04 or nip44 encryption methods depending on event kind
+ * @param kind The event kind to get the encryption method for
+ * @param signer The signer to use to get the encryption methods
+ * @param override The encryption method to use instead of the default
+ * @returns The encryption methods for the event kind
+ */
+export function getEncryptedContentEncryptionMethods(kind, signer, override) {
+    const method = override ?? EventContentEncryptionMethod[kind];
     if (!method)
         throw new Error(`Event kind ${kind} does not support encrypted content`);
     const encryption = signer[method];

package/dist/helpers/event-cache.d.ts

@@ -0,0 +1,15 @@
+import { NostrEvent } from "nostr-tools";
+import { IEventStoreStreams } from "../event-store/interface.js";
+/**
+ * Setups a process to write batches of new events from an event store to a cache
+ * @param eventStore - The event store to read from
+ * @param write - The function to write the events to the cache
+ * @param opts - The options for the process
+ * @param opts.batchTime - The time to wait before writing a batch (default: 5 seconds)
+ * @param opts.maxBatchSize - The maximum number of events to write in a batch
+ * @returns A function to stop the process
+ */
+export declare function presistEventsToCache(eventStore: IEventStoreStreams, write: (events: NostrEvent[]) => Promise<void>, opts?: {
+    maxBatchSize?: number;
+    batchTime?: number;
+}): () => void;

package/dist/helpers/event-cache.js

@@ -0,0 +1,32 @@
+import { bufferTime, filter } from "rxjs";
+import { logger } from "../logger.js";
+import { isFromCache } from "./index.js";
+const log = logger.extend("event-cache");
+/**
+ * Setups a process to write batches of new events from an event store to a cache
+ * @param eventStore - The event store to read from
+ * @param write - The function to write the events to the cache
+ * @param opts - The options for the process
+ * @param opts.batchTime - The time to wait before writing a batch (default: 5 seconds)
+ * @param opts.maxBatchSize - The maximum number of events to write in a batch
+ * @returns A function to stop the process
+ */
+export function presistEventsToCache(eventStore, write, opts) {
+    const time = opts?.batchTime ?? 5_000;
+    // Save all new events to the cache
+    const sub = eventStore.insert$
+        .pipe(
+    // Only select events that are not from the cache
+    filter((e) => !isFromCache(e)), 
+    // Buffer events for 5 seconds
+    opts?.maxBatchSize ? bufferTime(time, undefined, opts?.maxBatchSize ?? 100) : bufferTime(time), 
+    // Only select buffers with events
+    filter((b) => b.length > 0))
+        .subscribe((events) => {
+        // Save all new events to the cache
+        write(events)
+            .then(() => log(`Saved ${events.length} events to cache`))
+            .catch((e) => log(`Failed to save ${events.length} events to cache`, e));
+    });
+    return () => sub.unsubscribe();
+}

package/dist/helpers/expiration.js

@@ -1,11 +1,10 @@
 import { getOrComputeCachedValue } from "./cache.js";
 import { unixNow } from "./time.js";
-import { getTagValue } from "./event-tags.js";
 export const ExpirationTimestampSymbol = Symbol("expiration-timestamp");
 /** Returns the NIP-40 expiration timestamp for an event */
 export function getExpirationTimestamp(event) {
     return getOrComputeCachedValue(event, ExpirationTimestampSymbol, () => {
-        const expiration = getTagValue(event, "expiration");
+        const expiration = event.tags.find((t) => t[0] === "expiration")?.[1];
         return expiration ? parseInt(expiration) : undefined;
     });
 }

package/dist/helpers/hidden-content.d.ts

@@ -1,4 +1,4 @@
-import { EncryptedContentSigner, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
+import { EncryptedContentSigner, EncryptionMethod, getEncryptedContentEncryptionMethods } from "./encrypted-content.js";
 export declare const HiddenContentSymbol: symbol;
 export interface HiddenContentSigner extends EncryptedContentSigner {
 }
@@ -6,7 +6,7 @@ export declare const getHiddenContentEncryptionMethods: typeof getEncryptedConte
 /** Various event kinds that can have hidden content */
 export declare const HiddenContentKinds: Set<number>;
 /** Sets the encryption method for hidden content on a kind */
-export declare function setHiddenContentEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+export declare function setHiddenContentEncryptionMethod(kind: number, method: EncryptionMethod): number;
 /** Checks if an event can have hidden content */
 export declare function canHaveHiddenContent(kind: number): boolean;
 /** Checks if an event has hidden content */
@@ -31,7 +31,7 @@ export declare function unlockHiddenContent<T extends {
     kind: number;
     pubkey: string;
     content: string;
-}>(event: T, signer: EncryptedContentSigner): Promise<string>;
+}>(event: T, signer: EncryptedContentSigner, override?: EncryptionMethod): Promise<string>;
 /**
  * Sets the hidden content on an event and updates it if its part of an event store
  * @throws

package/dist/helpers/hidden-content.js

@@ -34,10 +34,10 @@ export function getHiddenContent(event) {
  * @param signer A signer to use to decrypt the content
  * @throws
  */
-export async function unlockHiddenContent(event, signer) {
+export async function unlockHiddenContent(event, signer, override) {
     if (!canHaveHiddenContent(event.kind))
         throw new Error("Event kind does not support hidden content");
-    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer);
+    const encryption = getEncryptedContentEncryptionMethods(event.kind, signer, override);
     const plaintext = await encryption.decrypt(event.pubkey, event.content);
     setHiddenContentCache(event, plaintext);
     return plaintext;

package/dist/helpers/hidden-tags.d.ts

@@ -1,11 +1,12 @@
 import { HiddenContentSigner } from "./hidden-content.js";
+import { EncryptionMethod } from "./encrypted-content.js";
 export declare const HiddenTagsSymbol: unique symbol;
 /** Various event kinds that can have hidden tags */
 export declare const HiddenTagsKinds: Set<number>;
 /** Checks if an event can have hidden tags */
 export declare function canHaveHiddenTags(kind: number): boolean;
 /** Sets the type of encryption to use for hidden tags on a kind */
-export declare function setHiddenTagsEncryptionMethod(kind: number, method: "nip04" | "nip44"): number;
+export declare function setHiddenTagsEncryptionMethod(kind: number, method: EncryptionMethod): number;
 /** Checks if an event has hidden tags */
 export declare function hasHiddenTags<T extends {
     kind: number;
@@ -19,25 +20,19 @@ export declare function getHiddenTags<T extends {
 /** Checks if the hidden tags are locked */
 export declare function isHiddenTagsLocked<T extends object>(event: T): boolean;
 /** Returns either nip04 or nip44 encryption method depending on list kind */
-export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-} | {
-    encrypt: (pubkey: string, plaintext: string) => Promise<string> | string;
-    decrypt: (pubkey: string, ciphertext: string) => Promise<string> | string;
-};
+export declare function getHiddenTagsEncryptionMethods(kind: number, signer: HiddenContentSigner): import("./encrypted-content.js").EncryptionMethods;
 /**
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
- * @param store An optional EventStore to notify about the update
+ * @param override The encryption method to use instead of the default
  * @throws
  */
 export declare function unlockHiddenTags<T extends {
     kind: number;
     pubkey: string;
     content: string;
-}>(event: T, signer: HiddenContentSigner): Promise<string[][]>;
+}>(event: T, signer: HiddenContentSigner, override?: EncryptionMethod): Promise<string[][]>;
 /**
  * Sets the hidden tags on an event and updates it if its part of an event store
  * @throws

package/dist/helpers/hidden-tags.js

@@ -58,15 +58,15 @@ export function getHiddenTagsEncryptionMethods(kind, signer) {
  * Decrypts the private list
  * @param event The list event to decrypt
  * @param signer A signer to use to decrypt the tags
- * @param store An optional EventStore to notify about the update
+ * @param override The encryption method to use instead of the default
  * @throws
  */
-export async function unlockHiddenTags(event, signer) {
+export async function unlockHiddenTags(event, signer, override) {
     if (!canHaveHiddenTags(event.kind))
         throw new Error("Event kind does not support hidden tags");
     // unlock hidden content is needed
     if (isHiddenContentLocked(event))
-        await unlockHiddenContent(event, signer);
+        await unlockHiddenContent(event, signer, override);
     return getHiddenTags(event);
 }
 /**

package/dist/helpers/index.d.ts

@@ -17,6 +17,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-cache.js";
 export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";

package/dist/helpers/index.js

@@ -17,6 +17,7 @@ export * from "./emoji.js";
 export * from "./encrypted-content-cache.js";
 export * from "./encrypted-content.js";
 export * from "./encryption.js";
+export * from "./event-cache.js";
 export * from "./event-tags.js";
 export * from "./event.js";
 export * from "./expiration.js";

package/dist/models/common.js

@@ -1,4 +1,4 @@
-import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
+import { combineLatest, defer, distinctUntilChanged, EMPTY, endWith, filter, finalize, from, map, merge, mergeWith, of, repeat, scan, takeUntil, tap, } from "rxjs";
 import { insertEventIntoDescendingList } from "nostr-tools/utils";
 import { createReplaceableAddress, getEventUID, getReplaceableIdentifier, isReplaceable, matchFilters, } from "../helpers/index.js";
 import { claimEvents } from "../observable/claim-events.js";
@@ -15,7 +15,9 @@ export function EventModel(pointer) {
         if (event)
             return of(event);
         // If there is a loader, use it to get the event
-        return events.eventLoader?.(pointer) ?? EMPTY;
+        if (!events.eventLoader)
+            return EMPTY;
+        return from(events.eventLoader(pointer)).pipe(filter((e) => !!e));
     }), 
     // Listen for new events
     events.insert$.pipe(filter((e) => e.id === pointer.id)), 
@@ -38,10 +40,16 @@ export function ReplaceableModel(pointer) {
             let event = events.getReplaceable(pointer.kind, pointer.pubkey, pointer.identifier);
             if (event)
                 return of(event);
-            else if (pointer.identifier !== undefined)
-                return events.addressableLoader?.(pointer) ?? EMPTY;
-            else
-                return events.replaceableLoader?.(pointer) ?? EMPTY;
+            else if (pointer.identifier !== undefined) {
+                if (!events.addressableLoader)
+                    return EMPTY;
+                return from(events.addressableLoader(pointer)).pipe(filter((e) => !!e));
+            }
+            else {
+                if (!events.replaceableLoader)
+                    return EMPTY;
+                return from(events.replaceableLoader(pointer)).pipe(filter((e) => !!e));
+            }
         }), 
         // subscribe to new events
         events.insert$.pipe(filter((e) => e.pubkey == pointer.pubkey &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "applesauce-core",
-  "version": "0.0.0-next-20250729145125",
+  "version": "0.0.0-next-20250808173123",
   "description": "",
   "type": "module",
   "main": "dist/index.js",