AppleSauce
    Preparing search index...

    Interface IAsyncEventStore

    The async event store interface

    interface IAsyncEventStore {
        addressableLoader?: (
            pointer: AddressPointer,
        ) => Observable<Event> | Promise<Event | undefined>;
        eventLoader?: (
            pointer: EventPointer,
        ) => Observable<Event> | Promise<Event | undefined>;
        insert$: Observable<Event>;
        remove$: Observable<Event>;
        replaceableLoader?: (
            pointer: AddressPointerWithoutD,
        ) => Observable<Event> | Promise<Event | undefined>;
        update$: Observable<Event>;
        add(event: Event): Promise<Event | null>;
        addressable(pointer: AddressPointer): Observable<Event | undefined>;
        blossomServers(user: string | ProfilePointer): Observable<URL[]>;
        claim(event: Event, claim: any): void;
        clearClaim(event: Event): void;
        comments(event: Event): Observable<Event[]>;
        contacts(user: string | ProfilePointer): Observable<ProfilePointer[]>;
        event(id: string | EventPointer): Observable<Event | undefined>;
        events(ids: string[]): Observable<Record<string, Event | undefined>>;
        filters(filters: Filter | Filter[], onlyNew?: boolean): Observable<Event>;
        getByFilters(filters: Filter | Filter[]): Promise<Event[]>;
        getEvent(id: string): Promise<Event | undefined>;
        getReplaceable(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Promise<Event | undefined>;
        getReplaceableHistory(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Promise<Event[] | undefined>;
        getTimeline(filters: Filter | Filter[]): Promise<Event[]>;
        hasEvent(id: string): Promise<boolean>;
        hasReplaceable(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Promise<boolean>;
        isClaimed(event: Event): boolean;
        mailboxes(
            user: string | ProfilePointer,
        ): Observable<{ inboxes: string[]; outboxes: string[] } | undefined>;
        model<T extends unknown, Args extends any[]>(
            constructor: ModelConstructor<T, Args, IAsyncEventStore>,
            ...args: Args,
        ): Observable<T>;
        mutes(user: string | ProfilePointer): Observable<Mutes | undefined>;
        profile(
            user: string | ProfilePointer,
        ): Observable<ProfileContent | undefined>;
        reactions(event: Event): Observable<Event[]>;
        remove(event: string | Event): Promise<boolean>;
        removeClaim(event: Event, claim: any): void;
        replaceable(pointer: AddressPointerWithoutD): Observable<Event | undefined>;
        replaceable(
            kind: number,
            pubkey: string,
            identifier?: string,
        ): Observable<Event | undefined>;
        replaceableSet(
            pointers: (AddressPointer | AddressPointerWithoutD)[],
        ): Observable<Record<string, Event | undefined>>;
        thread(root: string | AddressPointer | EventPointer): Observable<Thread>;
        timeline(
            filters: Filter | Filter[],
            onlyNew?: boolean,
        ): Observable<Event[]>;
        touch(event: Event): void;
        unclaimed(): Generator<Event>;
        update(event: Event): Promise<void>;
    }

    Hierarchy (View Summary)

    Implemented by

    Index

    Properties

    addressableLoader? eventLoader? insert$ remove$ replaceableLoader? update$

    Methods

    add addressable blossomServers claim clearClaim comments contacts event events filters getByFilters getEvent getReplaceable getReplaceableHistory getTimeline hasEvent hasReplaceable isClaimed mailboxes model mutes profile reactions remove removeClaim replaceable replaceableSet thread timeline touch unclaimed update

    Properties

    addressableLoader?: (
        pointer: AddressPointer,
    ) => Observable<Event> | Promise<Event | undefined>

    A method that will be called when an addressable event isn't found in the store

    eventLoader?: (
        pointer: EventPointer,
    ) => Observable<Event> | Promise<Event | undefined>

    A method that will be called when an event isn't found in the store

    insert$: Observable<Event>

    A stream of new events added to the store

    remove$: Observable<Event>

    A stream of events that have been removed

    replaceableLoader?: (
        pointer: AddressPointerWithoutD,
    ) => Observable<Event> | Promise<Event | undefined>

    A method that will be called when a replaceable event isn't found in the store

    update$: Observable<Event>

    A stream of events that have been updated

    Methods

    Settings

    Member Visibility

    On This Page

    Properties
    Methods