applesauce-core 0.0.0-next-20251209200210 → 0.0.0-next-20251231055351

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-event-store.d.ts

@@ -4,7 +4,7 @@ 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, IAsyncDeleteManager, IExpirationManager } from "./interface.js";
+import { IAsyncDeleteManager, IAsyncEventDatabase, IAsyncEventStore, IExpirationManager } from "./interface.js";
 export type AsyncEventStoreOptions = {
     /** Keep deleted events in the store */
     keepDeleted?: boolean;
@@ -44,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>;
@@ -59,8 +59,6 @@ export declare class AsyncEventStore extends EventModels implements IAsyncEventS
     private handleDeleteNotification;
     /** Handle an expired event by id */
     private handleExpiredNotification;
-    /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
     /**
      * 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
@@ -73,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 */

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

@@ -1,13 +1,14 @@
+import { verifyEvent as coreVerifyEvent } from "nostr-tools/pure";
 import { Subject } from "rxjs";
-import { EventStoreSymbol, FromCacheSymbol, getReplaceableIdentifier, isReplaceable, kinds, } from "../helpers/event.js";
+import { EventStoreSymbol, getReplaceableIdentifier, isReplaceable, kinds } from "../helpers/event.js";
 import { getExpirationTimestamp } from "../helpers/expiration.js";
-import { eventMatchesPointer, isEventPointer, isAddressPointer, } 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 { AsyncDeleteManager } from "./async-delete-manager.js";
+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 {
@@ -38,7 +39,7 @@ export class AsyncEventStore extends EventModels {
     }
     /** 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();
@@ -75,14 +76,6 @@ export class AsyncEventStore extends EventModels {
                 console.error("[applesauce-core] Error handling expired notification:", error);
             });
         });
-        // when events are added to the database, add the symbol
-        this.insert$.subscribe((event) => {
-            Reflect.set(event, EventStoreSymbol, this);
-        });
-        // when events are removed from the database, remove the symbol
-        this.remove$.subscribe((event) => {
-            Reflect.deleteProperty(event, EventStoreSymbol);
-        });
     }
     mapToMemory(event) {
         if (event === undefined)
@@ -122,18 +115,6 @@ export class AsyncEventStore extends EventModels {
             return;
         await this.remove(id);
     }
-    /** 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);
-    }
     /**
      * 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
@@ -151,6 +132,9 @@ export class AsyncEventStore extends EventModels {
         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) ? getReplaceableIdentifier(event) : undefined;
         // Don't insert the event if there is already a newer version
@@ -158,7 +142,8 @@ export class AsyncEventStore extends EventModels {
             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];
             }
         }
@@ -166,27 +151,28 @@ 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 === false && isReplaceable(event.kind)) {
             const existing = await this.database.getReplaceableHistory(event.kind, event.pubkey, identifier);
@@ -208,18 +194,20 @@ export class AsyncEventStore extends EventModels {
     /** Removes an event from the store and updates subscriptions */
     async remove(event) {
         const eventId = typeof event === "string" ? event : event.id;
-        let instance = this.memory?.getEvent(eventId);
+        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 */
@@ -252,29 +240,40 @@ 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
-        return (this.memory?.getReplaceableHistory(kind, pubkey, identifier) ??
+        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 */
@@ -297,30 +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;
+        return this.memory.prune(limit) ?? 0;
     }
 }

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

@@ -312,6 +312,9 @@ export class EventMemory {
     }
     /** Iterates over all events by time */
     *iterateTime(since, until) {
+        // Early return if array is empty
+        if (this.created_at.length === 0)
+            return;
         let startIndex = 0;
         let endIndex = this.created_at.length - 1;
         // If until is set, use binary search to find better start index
@@ -320,16 +323,21 @@ export class EventMemory {
                 return mid.created_at - until;
             })
             : undefined;
-        if (start)
-            startIndex = start[0];
+        if (start) {
+            startIndex = Math.max(0, Math.min(start[0], this.created_at.length - 1));
+        }
         // If since is set, use binary search to find better end index
         const end = since
             ? binarySearch(this.created_at, (mid) => {
                 return mid.created_at - since;
             })
             : undefined;
-        if (end)
-            endIndex = end[0];
+        if (end) {
+            endIndex = Math.max(0, Math.min(end[0], this.created_at.length - 1));
+        }
+        // Ensure startIndex <= endIndex
+        if (startIndex > endIndex)
+            return;
         // Yield events in the range, filtering by exact bounds
         for (let i = startIndex; i <= endIndex; i++) {
             const event = this.created_at[i];

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

@@ -2,24 +2,7 @@ import { Observable } from "rxjs";
 import { NostrEvent } from "../helpers/event.js";
 import { Filter } from "../helpers/filter.js";
 import { AddressPointer, AddressPointerWithoutD, EventPointer, ProfilePointer } from "../helpers/pointers.js";
-import { ProfileContent } from "../helpers/profile.js";
-import { IAsyncEventStore, IEventStore, ModelConstructor } from "./interface.js";
-/**
- * Core helpful subscriptions interface.
- * Contains only methods that use models from the core package.
- * Other packages (like applesauce-common) can extend this interface via module augmentation.
- */
-export interface IEventStoreModels {
-    /** Subscribe to a users profile */
-    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
-    /** Subscribe to a users contacts */
-    contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
-    /** Subscribe to a users mailboxes */
-    mailboxes(user: string | ProfilePointer): Observable<{
-        inboxes: string[];
-        outboxes: string[];
-    } | undefined>;
-}
+import { IAsyncEventStore, IEventStore, IEventSubscriptions, ModelConstructor } from "./interface.js";
 /**
  * Base class that provides model functionality for both sync and async event stores.
  * This class can be extended by other packages to add additional helpful subscription methods.
@@ -42,7 +25,7 @@ export interface IEventStoreModels {
  * }
  * ```
  */
-export declare class EventModels<TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> implements IEventStoreModels {
+export declare class EventModels<TStore extends IEventStore | IAsyncEventStore = IEventStore | IAsyncEventStore> implements IEventSubscriptions {
     /** A directory of all active models */
     models: Map<ModelConstructor<any, any[], TStore>, Map<string, Observable<any>>>;
     /** How long a model should be kept "warm" while nothing is subscribed to it */
@@ -55,8 +38,8 @@ export declare class EventModels<TStore extends IEventStore | IAsyncEventStore =
      * @param [onlyNew=false] Only subscribe to new events
      */
     filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<NostrEvent>;
-    /** Creates a {@link EventModel} */
-    event(pointer: string | EventPointer): Observable<NostrEvent | undefined>;
+    /** Subscribe to an event by pointer */
+    event(pointer: string | EventPointer | AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     /** Subscribe to a replaceable event by pointer */
     replaceable(pointer: AddressPointer | AddressPointerWithoutD): Observable<NostrEvent | undefined>;
     replaceable(kind: number, pubkey: string, identifier?: string): Observable<NostrEvent | undefined>;
@@ -65,7 +48,7 @@ export declare class EventModels<TStore extends IEventStore | IAsyncEventStore =
     /** Creates a {@link TimelineModel} */
     timeline(filters: Filter | Filter[], includeOldVersion?: boolean): Observable<NostrEvent[]>;
     /** Subscribe to a users profile */
-    profile(user: string | ProfilePointer): Observable<ProfileContent | undefined>;
+    profile(user: string | ProfilePointer): Observable<import("../helpers/profile.js").ProfileContent | undefined>;
     /** Subscribe to a users contacts */
     contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
     /** Subscribe to a users mailboxes */

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

@@ -1,5 +1,6 @@
 import hash_sum from "hash-sum";
-import { ReplaySubject, finalize, share, timer } from "rxjs";
+import { finalize, ReplaySubject, share, timer } from "rxjs";
+import { isEventPointer, } from "../helpers/pointers.js";
 import { EventModel, FiltersModel, ReplaceableModel, TimelineModel } from "../models/base.js";
 import { ContactsModel } from "../models/contacts.js";
 import { MailboxesModel } from "../models/mailboxes.js";
@@ -67,14 +68,16 @@ export class EventModels {
      * @param [onlyNew=false] Only subscribe to new events
      */
     filters(filters, onlyNew = false) {
+        if (!Array.isArray(filters))
+            filters = [filters];
         return this.model(FiltersModel, filters, onlyNew);
     }
-    // Helper methods for creating models
-    /** Creates a {@link EventModel} */
+    /** Subscribe to an event by pointer */
     event(pointer) {
-        if (typeof pointer === "string")
-            pointer = { id: pointer };
-        return this.model(EventModel, pointer);
+        if (typeof pointer === "string" || isEventPointer(pointer))
+            return this.model(EventModel, pointer);
+        else
+            return this.replaceable(pointer);
     }
     replaceable(...args) {
         let pointer;
@@ -92,7 +95,7 @@ export class EventModels {
     }
     /** Subscribe to an addressable event by pointer */
     addressable(pointer) {
-        return this.model(ReplaceableModel, pointer);
+        return this.replaceable(pointer);
     }
     /** Creates a {@link TimelineModel} */
     timeline(filters, includeOldVersion = false) {

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

@@ -44,7 +44,7 @@ export declare class EventStore extends EventModels implements IEventStore {
     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>;
@@ -58,7 +58,7 @@ export declare class EventStore extends EventModels implements IEventStore {
     /** Handle an expired event by id */
     private handleExpiredNotification;
     /** Copies important metadata from and identical event to another */
-    static mergeDuplicateEvent(source: NostrEvent, dest: NostrEvent): void;
+    static copySymbolsToDuplicateEvent(source: NostrEvent, dest: NostrEvent): boolean;
     /**
      * 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
@@ -71,9 +71,9 @@ export declare class EventStore extends EventModels implements IEventStore {
     /** 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 */
-    hasEvent(id: string): boolean;
+    hasEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): boolean;
     /** Get an event by id from the store */
-    getEvent(id: string): NostrEvent | undefined;
+    getEvent(id: string | EventPointer | AddressPointer | AddressPointerWithoutD): NostrEvent | undefined;
     /** Check if the store has a replaceable event */
     hasReplaceable(kind: number, pubkey: string, d?: string): boolean;
     /** Gets the latest version of a replaceable event */