Applesauce
    Preparing search index...

    Class PrimalCache

    Extended relay interface for primal caching server

    https://github.com/PrimalHQ/primal-server/blob/main/src/app_ext.jl

    Hierarchy

    • Relay
      • PrimalCache
    Index

    Constructors

    constructor

    Properties

    _nip11 _ready$ attempts$ authenticated$ authenticatedAs$ authentication$ authenticationResponse$ authRequiredForPublish$ authRequiredForRead$ challenge$ close$ closing$ connected$ enablePing error$ eventTimeout icon$ information$ keepAlive lastMessageAt$ limitations$ log message$ notice$ notices$ onUnresponsive? open$ pingFrequency pingTimeout publishRetry publishTimeout ready$ receivedAuthRequiredForEvent receivedAuthRequiredForReq reconnectTimer reqs$ requestReconnect socket status$ subscriptionReconnect supported$ url watchTower

    Accessors

    authenticated authenticatedAs authentication authenticationResponse challenge connected information lastMessageAt notices ready reqs

    Methods

    advancedFeed advancedSearch auth authenticate broadcastEvents broadcastReply cacheRequest checkFilterlist close count customRepeatOperator customRetryOperator customTimeoutOperator event explore exploreGlobalMostZapped4h exploreGlobalTrending24h exploreLegendCounts feedDirective feedDirective2 getAdvancedFeeds getDefaultRelays getFilterlist getInformation getLimitations getMediaMetadata getNotifications getNotificationsSeen getRecommendedUsers getSuggestedUsers getSupported multiplex negentropy noteMentions noteMentionsCount publish relays reportNote reportUser req request resetState scored scoredUsers scoredUsers24h search send setNotificationsSeen startReconnectTimer subscription sync timelineRequest trendingHashtags trendingHashtags4h trendingHashtags7d trendingImages trendingImages4h trustedUsers userProfileScoredContent userProfileScoredMediaThumbnails userSearch waitForAuth waitForReady afterOpen completeAnd completeOr createReconnectTimer defaultComplete fetchInformationDocument

    Constructors

    Properties

    Protected_nip11

    _nip11: RelayInformation | null

    Protected_ready$

    _ready$: BehaviorSubject<boolean>

    Internal subject that tracks the ready state of the relay

    attempts$: BehaviorSubject<number>

    How many times the relay has tried to reconnect

    authenticated$: Observable<boolean>

    Boolean authentication state (will be false if auth failed)

    authenticatedAs$: Observable<string | null>

    The pubkey of the authenticated user, or null if not authenticated

    authentication$: BehaviorSubject<KnownEvent<22242> | null>

    The authentication event sent to the relay

    authenticationResponse$: BehaviorSubject<PublishResponse | null>

    The response to the last AUTH message sent to the relay

    authRequiredForPublish$: Observable<boolean>
    authRequiredForRead$: Observable<boolean>
    challenge$: BehaviorSubject<string | null>

    The authentication challenge string from the relay

    close$: Subject<CloseEvent>

    An observable that emits when underlying websocket is closed

    closing$: Subject<void>

    An observable that emits when underlying websocket is closing due to unsubscribe or complete

    connected$: BehaviorSubject<boolean>

    Whether the relay is connected

    enablePing: boolean

    Enable/disable ping functionality (default false)

    error$: BehaviorSubject<Error | null>

    The last connection error

    eventTimeout: number

    How long to wait for an OK message from the relay (default 10s)

    icon$: Observable<string | undefined>

    An observable that emits the icon URL for the relay, or the favicon.ico URL for the relay

    information$: Observable<RelayInformation | null>

    An observable that emits the NIP-11 information document for the relay

    keepAlive: number

    How long to keep the connection alive after nothing is subscribed (default 30s)

    lastMessageAt$: Observable<number>
    limitations$: Observable<Partial<Limitations> | null | undefined>

    An observable that emits the limitations for the relay

    log: Debugger
    message$: Observable<any>

    A passive observable of all messages from the relay

    Subscribing to this will not connect to the relay

    notice$: Observable<string>

    A passive observable of NOTICE messages from the relay

    Subscribing to this will not connect to the relay

    notices$: BehaviorSubject<string[]>

    The notices from the relay

    onUnresponsive?: (
        info: {
            attempts: number;
            lastMessageAt: number;
            now: number;
            url: string;
        },
    ) => "reconnect"
    | "close"
    | "ignore"

    Policy hook for unresponsive connections

    open$: Subject<Event>

    An observable that emits when underlying websocket is opened

    pingFrequency: number

    How often to send pings in milliseconds (default 29000)

    pingTimeout: number

    How long to wait for EOSE response in milliseconds (default 20000)

    publishRetry: RetryConfig

    Default retry config for publish() method

    publishTimeout: number

    How long to wait for a publish to complete (default 30s)

    ready$: Observable<boolean>

    Whether the relay is ready for subscriptions or event publishing. setting this to false will cause all .req and .event observables to hang until the relay is ready

    receivedAuthRequiredForEvent: BehaviorSubject<boolean>
    receivedAuthRequiredForReq: BehaviorSubject<boolean>
    reconnectTimer: (
        error: Error | CloseEvent,
        attempts: number,
    ) => Observable<number>

    A method that returns an Observable that emits when the relay should reconnect

    reqs$: BehaviorSubject<Record<string, Filter[]>>

    Tracks active req() operations by subscription ID

    requestReconnect: RetryConfig

    Default reconnect config for request() method

    socket: WebSocketSubject<any>
    status$: Observable<RelayStatus>

    Observable of relay status (connection, authentication, and ready state)

    subscriptionReconnect: RetryConfig

    Default reconnect config for subscription() method

    supported$: Observable<number[] | null>

    An array of supported NIPs from the NIP-11 information document

    url: string
    watchTower: Observable<never>

    An internal observable that is responsible for watching all messages and updating state, subscribing to it will trigger a connection to the relay

    Accessors

    • get authenticated(): boolean

      Returns boolean

    • get authenticatedAs(): string | null

      Returns string | null

    • get authentication(): KnownEvent<22242> | null

      Returns KnownEvent<22242> | null

    • get authenticationResponse(): PublishResponse | null

      Returns PublishResponse | null

    • get challenge(): string | null

      Returns string | null

    • get connected(): boolean

      Returns boolean

    • get information(): RelayInformation | null

      Returns RelayInformation | null

    • get lastMessageAt(): number

      Returns number

    • get notices(): string[]

      Returns string[]

    • get ready(): boolean

      Returns boolean

    • get reqs(): Record<string, Filter[]>

      Returns Record<string, Filter[]>

    Methods

    • Advanced feed

      Parameters

      • params: {
            feed_type: string;
            limit?: number;
            offset?: number;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • Advanced search

      Parameters

      • params: {
            limit?: number;
            offset?: number;
            query: string;
            since?: number;
            sort?: "popular" | "trending" | "latest";
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • send and AUTH message

      Parameters

      Returns Promise<PublishResponse>

    • Authenticate with the relay using a signer

      Parameters

      • signer: AuthSigner

      Returns Promise<PublishResponse>

    • Make a "cache" request to the caching server

      Type Parameters

      Parameters

      • request:
            | ["explore_legend_counts", { pubkey: string }]
            | [
                "explore",
                {
                    apply_humaness_check?: boolean;
                    created_after?: number;
                    gm_mode?: boolean;
                    group_by_pubkey?: boolean;
                    include_top_zaps?: boolean;
                    limit?: number;
                    offset?: number;
                    pubkeys?: string[];
                    since?: number;
                    timeframe: "popular"
                    | "trending"
                    | "recent";
                    until?: number;
                    user_pubkey?: string;
                },
            ]
            | ["explore_global_trending_24h", { limit?: number }]
            | ["explore_global_mostzapped_4h", { limit?: number }]
            | [
                "scored",
                {
                    apply_humaness_check?: boolean;
                    created_after?: number;
                    gm_mode?: boolean;
                    group_by_pubkey?: boolean;
                    include_top_zaps?: boolean;
                    limit?: number;
                    offset?: number;
                    pubkeys?: string[];
                    since?: number;
                    timeframe: "popular"
                    | "trending"
                    | "recent";
                    until?: number;
                    user_pubkey?: string;
                },
            ]
            | ["scored_users", { limit?: number }]
            | ["scored_users_24h", { limit?: number }]
            | ["get_default_relays", {}]
            | ["get_recommended_users", { limit?: number }]
            | ["get_suggested_users", { limit?: number }]
            | [
                "user_profile_scored_content",
                {
                    created_after?: number;
                    limit?: number;
                    offset?: number;
                    pubkey: string;
                    since?: number;
                    until?: number;
                },
            ]
            | [
                "user_profile_scored_media_thumbnails",
                {
                    created_after?: number;
                    limit?: number;
                    offset?: number;
                    pubkey: string;
                    since?: number;
                    until?: number;
                },
            ]
            | [
                "search",
                {
                    limit?: number;
                    offset?: number;
                    query: string;
                    since?: number;
                    until?: number;
                },
            ]
            | [
                "advanced_search",
                {
                    limit?: number;
                    offset?: number;
                    query: string;
                    since?: number;
                    sort?: "popular"
                    | "trending"
                    | "latest";
                    until?: number;
                },
            ]
            | [
                "advanced_feed",
                {
                    feed_type: string;
                    limit?: number;
                    offset?: number;
                    since?: number;
                    until?: number;
                },
            ]
            | ["relays", {}]
            | [
                "get_notifications",
                {
                    limit?: number;
                    offset?: number;
                    pubkey: string;
                    since?: number;
                    until?: number;
                },
            ]
            | ["set_notifications_seen", { pubkey: string; until: number }]
            | ["get_notifications_seen", { pubkey: string }]
            | ["user_search", { limit?: number; query: string }]
            | [
                "feed_directive",
                {
                    feed_type: string;
                    limit?: number;
                    offset?: number;
                    pubkey: string;
                    since?: number;
                    until?: number;
                },
            ]
            | [
                "feed_directive_2",
                {
                    feed_type: string;
                    limit?: number;
                    offset?: number;
                    pubkey: string;
                    since?: number;
                    until?: number;
                },
            ]
            | ["get_advanced_feeds", {}]
            | ["trending_hashtags", { limit?: number }]
            | ["trending_hashtags_4h", { limit?: number }]
            | ["trending_hashtags_7d", { limit?: number }]
            | ["trending_images", { limit?: number }]
            | ["trending_images_4h", { limit?: number }]
            | ["report_user", { pubkey: string; reason: string }]
            | ["report_note", { event_id: string; reason: string }]
            | ["get_filterlist", {}]
            | ["check_filterlist", { pubkeys: string[] }]
            | ["broadcast_reply", { event: NostrEvent }]
            | ["broadcast_events", { events: NostrEvent[]; relays: string[] }]
            | ["trusted_users", { extended_response?: boolean; limit?: number }]
            | [
                "note_mentions",
                {
                    event_id?: string;
                    identifier?: string;
                    limit?: number;
                    offset?: number;
                    pubkey?: string;
                    user_pubkey?: string;
                },
            ]
            | ["note_mentions_count", { event_id: string }]
            | ["get_media_metadata", { urls: string[] }]

      Returns Observable<R["event"]>

    • Force close the connection

      Returns void

    • Create a COUNT observable that emits a single count response

      Parameters

      Returns Observable<RelayCountResponse>

    • Internal operator for creating the repeat() operator for resubscribing

      Type Parameters

      • T extends unknown = unknown

      Parameters

      • times: number | boolean | RepeatConfig | undefined

      Returns MonoTypeOperatorFunction<T>

    • Internal operator for creating the retry() operator for reconnecting to the websocket

      Type Parameters

      • T extends unknown = unknown

      Parameters

      • times: number | boolean | RetryConfig | undefined
      • Optionalbase: RetryConfig

      Returns MonoTypeOperatorFunction<T>

    • Internal operator for creating the timeout() operator

      Type Parameters

      • T extends unknown = unknown

      Parameters

      • timeout: number | boolean | undefined
      • defaultTimeout: number

      Returns MonoTypeOperatorFunction<T>

    • Send an EVENT or AUTH message and return an observable of PublishResponse that completes or errors

      Parameters

      Returns Observable<PublishResponse>

    • Explore content with various filters

      Parameters

      • params: {
            apply_humaness_check?: boolean;
            created_after?: number;
            gm_mode?: boolean;
            group_by_pubkey?: boolean;
            include_top_zaps?: boolean;
            limit?: number;
            offset?: number;
            pubkeys?: string[];
            since?: number;
            timeframe: "popular" | "trending" | "recent";
            until?: number;
            user_pubkey?: string;
        }

      Returns Promise<NostrEvent[]>

    • Feed directive

      Parameters

      • params: {
            feed_type: string;
            limit?: number;
            offset?: number;
            pubkey: string;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • Feed directive v2

      Parameters

      • params: {
            feed_type: string;
            limit?: number;
            offset?: number;
            pubkey: string;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • An async method that returns the NIP-11 information document for the relay

      Returns Promise<RelayInformation | null>

    • An async method that returns the NIP-11 limitations for the relay

      Returns Promise<Partial<Limitations> | null | undefined>

    • Get notifications

      Parameters

      • params: {
            limit?: number;
            offset?: number;
            pubkey: string;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • An async method that returns the supported NIPs for the relay

      Returns Promise<number[] | null>

    • Type Parameters

      • T

      Parameters

      • open: () => any
      • close: () => any
      • filter: (message: any) => boolean

      Returns Observable<T>

    • Negentropy sync event ids with the relay and an event store

      Parameters

      • store: NegentropyReadStore
      • filter: Filter
      • reconcile: ReconcileFunction
      • Optionalopts: NegentropySyncOptions

      Returns Promise<boolean>

    • Get note mentions

      Parameters

      • params: {
            event_id?: string;
            identifier?: string;
            limit?: number;
            offset?: number;
            pubkey?: string;
            user_pubkey?: string;
        }

      Returns Promise<NostrEvent[]>

    • Publishes an event to the relay and retries when relay errors or responds with auth-required ( default 3 retries )

      Parameters

      Returns Promise<PublishResponse>

    • Create a REQ observable that emits events or "EOSE" or errors

      Parameters

      • filters: FilterInput
      • Optionalopts: RelayReqOptions

      Returns Observable<RelayReqMessage>

    • Makes a single request that retires on errors and completes on EOSE

      Parameters

      • filters: FilterInput
      • Optionalopts: RelayRequestOptions

      Returns Observable<NostrEvent>

    • Returns void

    • Get scored content

      Parameters

      • params: {
            apply_humaness_check?: boolean;
            created_after?: number;
            gm_mode?: boolean;
            group_by_pubkey?: boolean;
            include_top_zaps?: boolean;
            limit?: number;
            offset?: number;
            pubkeys?: string[];
            since?: number;
            timeframe: "popular" | "trending" | "recent";
            until?: number;
            user_pubkey?: string;
        }

      Returns Promise<NostrEvent[]>

    • Search content

      Parameters

      • params: {
            limit?: number;
            offset?: number;
            query: string;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • Send a message to the relay

      Parameters

      • message: any

      Returns void

    • Set ready = false and start the reconnect timer

      Parameters

      • error: Error | CloseEvent

      Returns void

    • Creates a REQ that retries when relay errors ( default 3 retries )

      Parameters

      • filters: FilterInput
      • Optionalopts: RelayReqOptions

      Returns Observable<RelaySubscriptionResponse>

    • Negentropy sync events with the relay and an event store

      Parameters

      • store: NegentropySyncStore
      • filters: Filter
      • Optionaldirection: SyncDirection

      Returns Observable<NostrEvent>

    • Makes a cache request and returns a timeline of events

      Type Parameters

      • R extends RequestAndResponse<any, any, any>

      Parameters

      • method: R["req"][0]
      • args: R["req"][1]

      Returns Promise<R["event"][]>

    • Get trusted users

      Parameters

      • limit: number = 500
      • extendedResponse: boolean = true

      Returns Promise<NostrEvent[]>

    • Get user profile scored content

      Parameters

      • params: {
            created_after?: number;
            limit?: number;
            offset?: number;
            pubkey: string;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • Get user profile scored media thumbnails

      Parameters

      • params: {
            created_after?: number;
            limit?: number;
            offset?: number;
            pubkey: string;
            since?: number;
            until?: number;
        }

      Returns Promise<NostrEvent[]>

    • Wait for authentication state, make connection and then wait for authentication if required

      Type Parameters

      • T extends unknown = unknown

      Parameters

      Returns Observable<T>

    • Wait for the relay to be ready to accept connections

      Type Parameters

      • T extends unknown = unknown

      Parameters

      Returns Observable<T>

    • A complete condition that waits for the subscription to open

      Parameters

      • condition: RelayRequestCompleteOperator

      Returns RelayRequestCompleteOperator

    • An AND complete condition, that completes when all conditions are truthy

      Parameters

      • ...conditions: RelayRequestCompleteOperator[]

      Returns RelayRequestCompleteOperator

    • An OR complete condition, that completes when either condition is truthy

      Parameters

      • ...conditions: RelayRequestCompleteOperator[]

      Returns RelayRequestCompleteOperator

    • Static method to create a reconnection method for each relay

      Parameters

      • _relay: string

      Returns (_error?: Error | CloseEvent, tries?: number) => Observable<0>

    • A default complete condition that waits for the subscription to open and then completes after a timeout

      Parameters

      • timeout: number
      • OptionalafterOpen: number

      Returns RelayRequestCompleteOperator

    • Static method to fetch the NIP-11 information document for a relay

      Parameters

      • url: string

      Returns Observable<RelayInformation | null>

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties
    Accessors
    Methods
    advancedFeedadvancedSearchauthauthenticatebroadcastEventsbroadcastReplycacheRequestcheckFilterlistclosecountcustomRepeatOperatorcustomRetryOperatorcustomTimeoutOperatoreventexploreexploreGlobalMostZapped4hexploreGlobalTrending24hexploreLegendCountsfeedDirectivefeedDirective2getAdvancedFeedsgetDefaultRelaysgetFilterlistgetInformationgetLimitationsgetMediaMetadatagetNotificationsgetNotificationsSeengetRecommendedUsersgetSuggestedUsersgetSupportedmultiplexnegentropynoteMentionsnoteMentionsCountpublishrelaysreportNotereportUserreqrequestresetStatescoredscoredUsersscoredUsers24hsearchsendsetNotificationsSeenstartReconnectTimersubscriptionsynctimelineRequesttrendingHashtagstrendingHashtags4htrendingHashtags7dtrendingImagestrendingImages4htrustedUsersuserProfileScoredContentuserProfileScoredMediaThumbnailsuserSearchwaitForAuthwaitForReadyafterOpencompleteAndcompleteOrcreateReconnectTimerdefaultCompletefetchInformationDocument