applesauce-core 0.0.0-next-20251205152544 → 0.0.0-next-20251220152312

package/dist/event-factory/methods.js

@@ -1,4 +1,5 @@
 import { EncryptedContentSymbol } from "../helpers/encrypted-content.js";
+import { isEvent } from "../helpers/event.js";
 import { eventPipe } from "../helpers/pipeline.js";
 import { unixNow } from "../helpers/time.js";
 import { setClient } from "../operations/client.js";
@@ -36,5 +37,8 @@ export async function createEvent(context, blueprint, ...args) {
 }
 /** Modifies an event using a context and a set of operations */
 export async function modifyEvent(event, context, ...operations) {
+    // NOTE: Unwrapping evnet object in order to handle cast events from applesauce-common
+    if ("event" in event && isEvent(event.event))
+        event = event.event;
     return await wrapCommon(stripSignature(), stripStamp(), updateCreatedAt(), ...operations)(event, context);
 }

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

@@ -0,0 +1,26 @@
+import { Observable } from "rxjs";
+import { NostrEvent } from "../helpers/event.js";
+import { DeleteEventNotification, IAsyncDeleteManager } from "./interface.js";
+/** Async manager for deletion state, ensuring users can only delete their own events */
+export declare class AsyncDeleteManager implements IAsyncDeleteManager {
+    /** A stream of pointers that may have been deleted */
+    readonly deleted$: Observable<DeleteEventNotification>;
+    /** Internal sync delete manager instance for state */
+    private internal;
+    constructor();
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    add(deleteEvent: NostrEvent): Promise<DeleteEventNotification[]>;
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    check(event: NostrEvent): Promise<boolean>;
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    filter(events: NostrEvent[]): Promise<NostrEvent[]>;
+}

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

@@ -0,0 +1,33 @@
+import { DeleteManager } from "./delete-manager.js";
+/** Async manager for deletion state, ensuring users can only delete their own events */
+export class AsyncDeleteManager {
+    /** A stream of pointers that may have been deleted */
+    deleted$;
+    /** Internal sync delete manager instance for state */
+    internal;
+    constructor() {
+        this.internal = new DeleteManager();
+        this.deleted$ = this.internal.deleted$;
+    }
+    /**
+     * Process a kind 5 delete event
+     * Extracts event pointers and address pointers from the delete event
+     * Enforces that users can only delete their own events
+     */
+    async add(deleteEvent) {
+        return this.internal.add(deleteEvent);
+    }
+    /**
+     * Check if an event is deleted
+     * Verifies the event was deleted by its own author
+     */
+    async check(event) {
+        return this.internal.check(event);
+    }
+    /**
+     * Filter out all deleted events from an array of events
+     */
+    async filter(events) {
+        return this.internal.filter(events);
+    }
+}

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

@@ -4,16 +4,38 @@ import { Filter } from "../helpers/filter.js";
 import { AddressPointer, AddressPointerWithoutD, EventPointer } from "../helpers/pointers.js";
 import { EventMemory } from "./event-memory.js";
 import { EventModels } from "./event-models.js";
-import { IAsyncEventDatabase, IAsyncEventStore } from "./interface.js";
+import { IAsyncDeleteManager, IAsyncEventDatabase, IAsyncEventStore, IExpirationManager } from "./interface.js";
+export type AsyncEventStoreOptions = {
+    /** Keep deleted events in the store */
+    keepDeleted?: boolean;
+    /** Keep expired events in the store */
+    keepExpired?: boolean;
+    /** Enable this to keep old versions of replaceable events */
+    keepOldVersions?: boolean;
+    /** The database to use for storing events */
+    database: IAsyncEventDatabase;
+    /** Custom {@link IAsyncDeleteManager} implementation */
+    deleteManager?: IAsyncDeleteManager;
+    /** Custom {@link IExpirationManager} implementation */
+    expirationManager?: IExpirationManager;
+    /** The method used to verify events */
+    verifyEvent?: (event: NostrEvent) => boolean;
+};
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export declare class AsyncEventStore extends EventModels implements IAsyncEventStore {
     database: IAsyncEventDatabase;
     /** Optional memory database for ensuring single event instances */
     memory: EventMemory;
+    /** Manager for handling event deletions with authorization */
+    private deletes;
+    /** Manager for handling event expirations */
+    private expiration;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions: boolean;
-    /** Enable this to keep expired events */
+    /** Keep expired events in the store */
     keepExpired: boolean;
+    /** Keep deleted events in the store */
+    keepDeleted: boolean;
     /** The method used to verify events */
     private _verifyEventMethod?;
     /** Get the method used to verify events */
@@ -22,7 +44,7 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     set verifyEvent(method: undefined | ((event: NostrEvent) => boolean));
     /** A stream of new events added to the store */
     insert$: Subject<import("nostr-tools/core").Event>;
-    /** A stream of events that have been updated */
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
     update$: Subject<import("nostr-tools/core").Event>;
     /** A stream of events that have been removed */
     remove$: Subject<import("nostr-tools/core").Event>;
@@ -30,23 +52,13 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
      * A method that will be called when an event isn't found in the store
      */
     eventLoader?: (pointer: EventPointer | AddressPointer | AddressPointerWithoutD) => Observable<NostrEvent> | Promise<NostrEvent | undefined>;
-    constructor(database: IAsyncEventDatabase);
+    constructor(options: AsyncEventStoreOptions);
     /** A method to add all events to memory to ensure there is only ever a single instance of an event */
     private mapToMemory;
-    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(): Promise<void>;
-    protected handleDeleteEvent(deleteEvent: NostrEvent): Promise<void>;
-    /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
+    /** Handle a delete event by pointer */
+    private handleDeleteNotification;
+    /** Handle an expired event by id */
+    private handleExpiredNotification;
     /**
      * Adds an event to the store and update subscriptions
      * @returns The existing event or the event that was added, if it was ignored returns null
@@ -59,9 +71,9 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     /** 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 */
-    hasEvent(id: string): Promise<boolean>;
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<boolean>;
     /** Get an event by id from the store */
-    getEvent(id: string): Promise<NostrEvent | undefined>;
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): Promise<NostrEvent | undefined>;
     /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): Promise<boolean>;
     /** Gets the latest version of a replaceable event */
@@ -86,8 +98,4 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     unclaimed(): Generator<NostrEvent>;
     /** Removes any event that is not being used by a subscription */
     prune(limit?: number): number;
-    /** Returns an observable that completes when an event is removed */
-    removed(id: string): Observable<never>;
-    /** Creates an observable that emits when event is updated */
-    updated(event: string | NostrEvent): Observable<NostrEvent>;
 }

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

@@ -1,22 +1,30 @@
-import { EMPTY, filter, mergeMap, Subject, take } from "rxjs";
-import { getDeleteCoordinates, getDeleteIds } from "../helpers/delete.js";
-import { createReplaceableAddress, EventStoreSymbol, FromCacheSymbol, isAddressableKind, isReplaceable, kinds, } from "../helpers/event.js";
+import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
+import { Subject } from "rxjs";
+import { EventStoreSymbol, getReplaceableIdentifier, isReplaceable, kinds } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
-import { parseCoordinate } from "../helpers/pointers.js";
-import { addSeenRelay, getSeenRelays } from "../helpers/relays.js";
+import { eventMatchesPointer, isAddressPointer, isEventPointer, } from "../helpers/pointers.js";
+import { addSeenRelay } from "../helpers/relays.js";
 import { unixNow } from "../helpers/time.js";
+import { AsyncDeleteManager } from "./async-delete-manager.js";
 import { EventMemory } from "./event-memory.js";
 import { EventModels } from "./event-models.js";
-import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
+import { EventStore } from "./event-store.js";
+import { ExpirationManager } from "./expiration-manager.js";
 /** An async wrapper around an async event database that handles replaceable events, deletes, and models */
 export class AsyncEventStore extends EventModels {
     database;
     /** Optional memory database for ensuring single event instances */
     memory;
+    /** Manager for handling event deletions with authorization */
+    deletes;
+    /** Manager for handling event expirations */
+    expiration;
     /** Enable this to keep old versions of replaceable events */
     keepOldVersions = false;
-    /** Enable this to keep expired events */
+    /** Keep expired events in the store */
     keepExpired = false;
+    /** Keep deleted events in the store */
+    keepDeleted = false;
     /** The method used to verify events */
     _verifyEventMethod = coreVerifyEvent;
     /** Get the method used to verify events */
@@ -26,13 +34,12 @@ export class AsyncEventStore extends EventModels {
     /** Sets the method used to verify events */
     set verifyEvent(method) {
         this._verifyEventMethod = method;
-        if (method === undefined) {
+        if (method === undefined)
             console.warn("[applesauce-core] AsyncEventStore.verifyEvent is undefined; signature checks are disabled.");
-        }
     }
     /** A stream of new events added to the store */
     insert$ = new Subject();
-    /** A stream of events that have been updated */
+    /** A stream of events that have been updated (Warning: this is a very noisy stream, use with caution) */
     update$ = new Subject();
     /** A stream of events that have been removed */
     remove$ = new Subject();
@@ -40,17 +47,34 @@ export class AsyncEventStore extends EventModels {
      * A method that will be called when an event isn't found in the store
      */
     eventLoader;
-    constructor(database) {
+    constructor(options) {
         super();
-        this.database = database;
+        this.database = options.database;
         this.memory = new EventMemory();
-        // when events are added to the database, add the symbol
-        this.insert$.subscribe((event) => {
-            Reflect.set(event, EventStoreSymbol, this);
+        // Set options if provided
+        if (options.keepDeleted !== undefined)
+            this.keepDeleted = options.keepDeleted;
+        if (options.keepExpired !== undefined)
+            this.keepExpired = options.keepExpired;
+        if (options.keepOldVersions !== undefined)
+            this.keepOldVersions = options.keepOldVersions;
+        if (options.verifyEvent)
+            this.verifyEvent = options.verifyEvent;
+        // Use provided delete manager or create a default one
+        this.deletes = options.deleteManager ?? new AsyncDeleteManager();
+        // Listen to delete notifications and remove matching events
+        this.deletes.deleted$.subscribe((notification) => {
+            this.handleDeleteNotification(notification).catch((error) => {
+                console.error("[applesauce-core] Error handling delete notification:", error);
+            });
         });
-        // when events are removed from the database, remove the symbol
-        this.remove$.subscribe((event) => {
-            Reflect.deleteProperty(event, EventStoreSymbol);
+        // Create expiration manager
+        this.expiration = options.expirationManager ?? new ExpirationManager();
+        // Listen to expired events and remove them from the store
+        this.expiration.expired$.subscribe((id) => {
+            this.handleExpiredNotification(id).catch((error) => {
+                console.error("[applesauce-core] Error handling expired notification:", error);
+            });
         });
     }
     mapToMemory(event) {
@@ -60,100 +84,36 @@ export class AsyncEventStore extends EventModels {
             return event;
         return this.memory.add(event);
     }
-    // delete state
-    deletedIds = new Set();
-    deletedCoords = new Map();
-    checkDeleted(event) {
-        if (typeof event === "string")
-            return this.deletedIds.has(event);
-        else {
-            if (this.deletedIds.has(event.id))
-                return true;
-            if (isAddressableKind(event.kind)) {
-                const identifier = event.tags.find((t) => t[0] === "d")?.[1];
-                const deleted = this.deletedCoords.get(createReplaceableAddress(event.kind, event.pubkey, identifier));
-                if (deleted)
-                    return deleted > event.created_at;
-            }
-        }
-        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)
+    /** Handle a delete event by pointer */
+    async handleDeleteNotification({ pointer, until }) {
+        // Skip if keeping deleted events
+        if (this.keepDeleted)
             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 */
-    async pruneExpired() {
-        const now = unixNow();
-        for (const [id, expiration] of this.expirations) {
-            if (expiration <= now) {
-                this.expirations.delete(id);
-                await this.remove(id);
-            }
-        }
-        // Cleanup timers
-        if (this.expirationTimeout)
-            clearTimeout(this.expirationTimeout);
-        this.nextExpirationCheck = null;
-        this.expirationTimeout = null;
-    }
-    // handling delete events
-    async handleDeleteEvent(deleteEvent) {
-        const ids = getDeleteIds(deleteEvent);
-        for (const id of ids) {
-            this.deletedIds.add(id);
-            // remove deleted events in the database
-            await this.remove(id);
+        if (isEventPointer(pointer)) {
+            // For event pointers, get the event by ID and remove if it exists
+            const event = await this.getEvent(pointer.id);
+            if (event && until >= event.created_at && eventMatchesPointer(event, pointer))
+                await this.remove(event);
         }
-        const coords = getDeleteCoordinates(deleteEvent);
-        for (const coord of coords) {
-            this.deletedCoords.set(coord, Math.max(this.deletedCoords.get(coord) ?? 0, deleteEvent.created_at));
-            // Parse the nostr address coordinate
-            const parsed = parseCoordinate(coord);
-            if (!parsed)
-                continue;
-            // Remove older versions of replaceable events
-            const events = await this.database.getReplaceableHistory(parsed.kind, parsed.pubkey, parsed.identifier);
+        else if (isAddressPointer(pointer)) {
+            // For address pointers, get all events matching the address and remove if deleted
+            const events = await this.getReplaceableHistory(pointer.kind, pointer.pubkey, pointer.identifier);
             if (events) {
                 for (const event of events) {
-                    if (event.created_at < deleteEvent.created_at)
+                    // Remove the event if its older than the delete notification and matches the pointer
+                    if (until >= event.created_at && eventMatchesPointer(event, pointer)) {
                         await this.remove(event);
+                    }
                 }
             }
         }
     }
-    /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source, dest) {
-        const relays = getSeenRelays(source);
-        if (relays) {
-            for (const relay of relays)
-                addSeenRelay(dest, relay);
-        }
-        // copy the from cache symbol only if its true
-        const fromCache = Reflect.get(source, FromCacheSymbol);
-        if (fromCache && !Reflect.get(dest, FromCacheSymbol))
-            Reflect.set(dest, FromCacheSymbol, fromCache);
+    /** Handle an expired event by id */
+    async handleExpiredNotification(id) {
+        // Skip if keeping expired events
+        if (this.keepExpired)
+            return;
+        await this.remove(id);
     }
     /**
      * Adds an event to the store and update subscriptions
@@ -161,23 +121,29 @@ export class AsyncEventStore extends EventModels {
      */
     async add(event, fromRelay) {
         // Handle delete events differently
-        if (event.kind === kinds.EventDeletion)
-            await this.handleDeleteEvent(event);
+        if (event.kind === kinds.EventDeletion) {
+            await this.deletes.add(event);
+            return event;
+        }
         // Ignore if the event was deleted
-        if (this.checkDeleted(event))
+        if (await this.deletes.check(event))
             return event;
         // Reject expired events if keepExpired is false
         const expiration = getExpirationTimestamp(event);
         if (this.keepExpired === false && expiration && expiration <= unixNow())
             return null;
+        // Attach relay this event was from
+        if (fromRelay)
+            addSeenRelay(event, fromRelay);
         // Get the replaceable identifier
-        const identifier = isReplaceable(event.kind) ? event.tags.find((t) => t[0] === "d")?.[1] : undefined;
+        const identifier = isReplaceable(event.kind) ? getReplaceableIdentifier(event) : undefined;
         // Don't insert the event if there is already a newer version
-        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+        if (this.keepOldVersions === false && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             // If there is already a newer version, copy cached symbols and return existing event
             if (existing && existing.length > 0 && existing[0].created_at >= event.created_at) {
-                AsyncEventStore.mergeDuplicateEvent(event, existing[0]);
+                if (EventStore.copySymbolsToDuplicateEvent(event, existing[0]))
+                    await this.update(existing[0]);
                 return existing[0];
             }
         }
@@ -185,29 +151,30 @@ export class AsyncEventStore extends EventModels {
         if (this.verifyEvent && this.verifyEvent(event) === false)
             return null;
         // Always add event to memory
-        const existing = this.memory?.add(event);
+        const existing = this.memory.add(event);
         // If the memory returned a different instance, this is a duplicate event
         if (existing && existing !== event) {
             // Copy cached symbols and return existing event
-            AsyncEventStore.mergeDuplicateEvent(event, existing);
-            // attach relay this event was from
-            if (fromRelay)
-                addSeenRelay(existing, fromRelay);
+            if (EventStore.copySymbolsToDuplicateEvent(event, existing))
+                await this.update(existing);
             return existing;
         }
         // Insert event into database
         const inserted = this.mapToMemory(await this.database.add(event));
-        // Copy cached data if its a duplicate event
-        if (event !== inserted)
-            AsyncEventStore.mergeDuplicateEvent(event, inserted);
-        // attach relay this event was from
-        if (fromRelay)
-            addSeenRelay(inserted, fromRelay);
-        // Emit insert$ signal
-        if (inserted === event)
+        // If the event is the same as the inserted event, its a new event
+        if (inserted === event) {
+            // Set the event store on the event
+            Reflect.set(inserted, EventStoreSymbol, this);
+            // Emit insert$ signal
             this.insert$.next(inserted);
+        }
+        else {
+            // Copy cached data if its a duplicate event
+            if (EventStore.copySymbolsToDuplicateEvent(event, inserted))
+                await this.update(inserted);
+        }
         // remove all old version of the replaceable event
-        if (!this.keepOldVersions && isReplaceable(event.kind)) {
+        if (this.keepOldVersions === false && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
             if (existing && existing.length > 0) {
                 const older = Array.from(existing).filter((e) => e.created_at < event.created_at);
@@ -219,29 +186,37 @@ export class AsyncEventStore extends EventModels {
                     return existing[0];
             }
         }
-        // Add event to expiration map
-        if (this.keepExpired === false && expiration)
-            this.handleExpiringEvent(inserted);
+        // Add event to expiration manager if it has an expiration tag
+        if (this.keepExpired === false && expiration !== undefined)
+            this.expiration.track(inserted);
         return inserted;
     }
     /** Removes an event from the store and updates subscriptions */
     async remove(event) {
-        let instance = this.memory?.getEvent(typeof event === "string" ? event : event.id);
+        const eventId = typeof event === "string" ? event : event.id;
+        let instance = this.memory.getEvent(eventId);
+        // Remove from expiration manager
+        this.expiration.forget(eventId);
+        // Remove the event store from the event
+        if (instance)
+            Reflect.deleteProperty(instance, EventStoreSymbol);
         // Remove from memory if available
         if (this.memory)
             this.memory.remove(event);
         // Remove the event from the database
         const removed = await this.database.remove(event);
         // If the event was removed, notify the subscriptions
-        if (removed && instance) {
+        if (removed && instance)
             this.remove$.next(instance);
-        }
         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 expiration manager
+        for (const event of eventsToRemove)
+            this.expiration.forget(event.id);
         // Remove from memory if available
         if (this.memory)
             this.memory.removeByFilters(filters);
@@ -265,33 +240,41 @@ export class AsyncEventStore extends EventModels {
     }
     /** Check if the store has an event by id */
     async hasEvent(id) {
-        // Check if the event exists in memory first, then in the database
-        return (this.memory?.hasEvent(id) ?? false) || (await this.database.hasEvent(id));
+        if (typeof id === "string")
+            return this.memory.hasEvent(id) || this.database.hasEvent(id);
+        // If its a pointer, use the advanced has event method to resolve
+        else if (isEventPointer(id))
+            return this.memory.hasEvent(id.id) || this.database.hasEvent(id.id);
+        else
+            return this.hasReplaceable(id.kind, id.pubkey, id.identifier);
     }
     /** Get an event by id from the store */
     async getEvent(id) {
         // Get the event from memory first, then from the database
-        return this.memory?.getEvent(id) ?? this.mapToMemory(await this.database.getEvent(id));
+        if (typeof id === "string")
+            return this.memory.getEvent(id) ?? this.mapToMemory(await this.database.getEvent(id));
+        // If its a pointer, use the advanced get event method to resolve
+        else if (isEventPointer(id))
+            return this.memory.getEvent(id.id) ?? this.mapToMemory(await this.database.getEvent(id.id));
+        else
+            return this.getReplaceable(id.kind, id.pubkey, id.identifier);
     }
     /** Check if the store has a replaceable event */
     async hasReplaceable(kind, pubkey, d) {
         // Check if the event exists in memory first, then in the database
-        return ((this.memory?.hasReplaceable(kind, pubkey, d) ?? false) || (await this.database.hasReplaceable(kind, pubkey, d)));
+        return this.memory.hasReplaceable(kind, pubkey, d) || this.database.hasReplaceable(kind, pubkey, d);
     }
     /** Gets the latest version of a replaceable event */
     async getReplaceable(kind, pubkey, identifier) {
         // Get the event from memory first, then from the database
-        return (this.memory?.getReplaceable(kind, pubkey, identifier) ??
+        return (this.memory.getReplaceable(kind, pubkey, identifier) ??
             this.mapToMemory(await this.database.getReplaceable(kind, pubkey, identifier)));
     }
     /** Returns all versions of a replaceable event */
     async getReplaceableHistory(kind, pubkey, identifier) {
         // Get the events from memory first, then from the database
-        const memoryEvents = this.memory?.getReplaceableHistory(kind, pubkey, identifier);
-        if (memoryEvents)
-            return memoryEvents;
-        const dbEvents = await this.database.getReplaceableHistory(kind, pubkey, identifier);
-        return dbEvents?.map((e) => this.mapToMemory(e) ?? e);
+        return (this.memory.getReplaceableHistory(kind, pubkey, identifier) ??
+            (await this.database.getReplaceableHistory(kind, pubkey, identifier))?.map((e) => this.mapToMemory(e) ?? e));
     }
     /** Get all events matching a filter */
     async getByFilters(filters) {
@@ -299,7 +282,7 @@ export class AsyncEventStore extends EventModels {
         const events = await this.database.getByFilters(filters);
         // Map events to memory if available for better performance
         if (this.memory)
-            return events.map((e) => this.mapToMemory(e) ?? e);
+            return events.map((e) => this.mapToMemory(e));
         else
             return events;
     }
@@ -313,47 +296,30 @@ export class AsyncEventStore extends EventModels {
     }
     /** Passthrough method for the database.touch */
     touch(event) {
-        return this.memory?.touch(event);
+        return this.memory.touch(event);
     }
     /** Increments the claim count on the event and touches it */
     claim(event) {
-        return this.memory?.claim(event);
+        return this.memory.claim(event);
     }
     /** Checks if an event is claimed by anything */
     isClaimed(event) {
-        return this.memory?.isClaimed(event) ?? false;
+        return this.memory.isClaimed(event) ?? false;
     }
     /** Decrements the claim count on an event */
     removeClaim(event) {
-        return this.memory?.removeClaim(event);
+        return this.memory.removeClaim(event);
     }
     /** Removes all claims on an event */
     clearClaim(event) {
-        return this.memory?.clearClaim(event);
+        return this.memory.clearClaim(event);
     }
     /** Pass through method for the database.unclaimed */
     unclaimed() {
-        return this.memory?.unclaimed() || (function* () { })();
+        return this.memory.unclaimed() || (function* () { })();
     }
     /** Removes any event that is not being used by a subscription */
     prune(limit) {
-        return this.memory?.prune(limit) ?? 0;
-    }
-    /** Returns an observable that completes when an event is removed */
-    removed(id) {
-        const deleted = this.checkDeleted(id);
-        if (deleted)
-            return EMPTY;
-        return this.remove$.pipe(
-        // listen for removed events
-        filter((e) => e.id === id), 
-        // complete as soon as we find a matching removed event
-        take(1), 
-        // switch to empty
-        mergeMap(() => EMPTY));
-    }
-    /** Creates an observable that emits when event is updated */
-    updated(event) {
-        return this.update$.pipe(filter((e) => e.id === event || e === event));
+        return this.memory.prune(limit) ?? 0;
     }
 }