applesauce-core 0.0.0-next-20250729145125 → 0.0.0-next-20250806165639

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/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/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-20250806165639",
   "description": "",
   "type": "module",
   "main": "dist/index.js",