Update docs, tweak url based event derivation

packages/app/src/index.ts

@@ -85,12 +85,12 @@ const _relayGetter = (fn?: (relay: RelayProfile) => any) =>
   })
 
 export const getPubkeyRelays = (pubkey: string, mode?: RelayMode) =>
-  mode === RelayMode.Messages
+  mode === RelayMode.Messaging
     ? getRelaysFromList(getMessagingRelayList(pubkey))
     : getRelaysFromList(getRelayList(pubkey), mode)
 
 export const derivePubkeyRelays = (pubkey: string, mode?: RelayMode) =>
-  mode === RelayMode.Messages
+  mode === RelayMode.Messaging
     ? derived(deriveMessagingRelayList(pubkey), list => getRelaysFromList(list))
     : derived(deriveRelayList(pubkey), list => getRelaysFromList(list, mode))
 

packages/app/src/messagingRelayLists.ts

@@ -15,6 +15,8 @@ export const messagingRelayLists = deriveItems(messagingRelayListsByPubkey)
 
 export const getMessagingRelayListsByPubkey = getter(messagingRelayListsByPubkey)
 
+export const getMessagingRelayLists = getter(messagingRelayLists)
+
 export const getMessagingRelayList = (pubkey: string) => getMessagingRelayListsByPubkey().get(pubkey)
 
 export const forceLoadMessagingRelayList = makeForceLoadItem(makeOutboxLoader(MESSAGING_RELAYS), getMessagingRelayList)

packages/lib/src/Tools.ts

@@ -634,7 +634,7 @@ export const sort = <T>(xs: T[]) => [...xs].sort()
  * @param xs - Array to sort
  * @returns Sorted array
  */
-export const sortBy = <T>(f: (x: T) => any, xs: T[]) =>
+export const sortBy = <T>(f: (x: T) => any, xs: Iterable<T>) =>
   [...xs].sort((a: T, b: T) => {
     const x = f(a)
     const y = f(b)

packages/router/src/index.ts

@@ -174,14 +174,14 @@ export class Router {
 
   FromUser = () => this.FromRelays(this.getRelaysForUser(RelayMode.Write))
 
-  UserMessages = () => this.FromRelays(this.getRelaysForUser(RelayMode.Messages))
+  MessagesForUser = () => this.FromRelays(this.getRelaysForUser(RelayMode.Messaging))
 
   ForPubkey = (pubkey: string) => this.FromRelays(this.getRelaysForPubkey(pubkey, RelayMode.Read))
 
   FromPubkey = (pubkey: string) => this.FromRelays(this.getRelaysForPubkey(pubkey, RelayMode.Write))
 
   MessagesForPubkey = (pubkey: string) =>
-    this.FromRelays(this.getRelaysForPubkey(pubkey, RelayMode.Messages))
+    this.FromRelays(this.getRelaysForPubkey(pubkey, RelayMode.Messaging))
 
   ForPubkeys = (pubkeys: string[]) => this.merge(pubkeys.map(pubkey => this.ForPubkey(pubkey)))
 
@@ -371,7 +371,7 @@ export const getFilterSelectionsForWraps = (filter: Filter) => {
   return [
     {
       filter: {...filter, kinds: [WRAP]},
-      scenario: Router.get().UserMessages(),
+      scenario: Router.get().MessagesForUser(),
     },
   ]
 }

packages/store/src/repository.ts

@@ -1,5 +1,5 @@
 import {derived, readable, Readable} from "svelte/store"
-import {on, now, indexBy, mapPop, Maybe, MaybeAsync, call, sortBy, first} from "@welshman/lib"
+import {on, assoc, now, indexBy, mapPop, Maybe, MaybeAsync, call, sortBy, first} from "@welshman/lib"
 import {matchFilters, getIdFilters, Filter, TrustedEvent} from "@welshman/util"
 import {Repository, RepositoryUpdate, Tracker} from "@welshman/net"
 import {deriveDeduplicated} from "./misc.js"
@@ -48,117 +48,84 @@ export const deriveEventsById = ({
 export const deriveEvents = (eventsByIdStore: Readable<EventsById>) =>
   deriveDeduplicated(eventsByIdStore, eventsById => Array.from(eventsById.values()))
 
-export const deriveEventsAsc = (eventsStore: Readable<TrustedEvent[]>) =>
-  deriveDeduplicated(eventsStore, events => sortBy(e => e.created_at, events))
+export const deriveEventsAsc = (eventsByIdStore: Readable<EventsById>) =>
+  deriveDeduplicated(eventsByIdStore, eventsById => sortBy(e => e.created_at, eventsById.values()))
 
-export const deriveEventsDesc = (eventsStore: Readable<TrustedEvent[]>) =>
-  deriveDeduplicated(eventsStore, events => sortBy(e => -e.created_at, events))
+export const deriveEventsDesc = (eventsByIdStore: Readable<EventsById>) =>
+  deriveDeduplicated(eventsByIdStore, eventsById => sortBy(e => -e.created_at, eventsById.values()))
 
 // Events by id by url
 
-export type EventsByIdByUrl = Map<string, EventsById>
-
-export type DeriveEventsByIdByUrlOptions = DeriveEventsByIdOptions & {
+export type DeriveEventsByIdForUrlOptions = DeriveEventsByIdOptions & {
+  url: string
   tracker: Tracker
 }
 
-export const deriveEventsByIdByUrl = ({
+export const deriveEventsByIdForUrl = ({
+  url,
   filters,
   tracker,
   repository,
   includeDeleted,
-}: DeriveEventsByIdByUrlOptions) => {
-  const eventsByIdByUrl: EventsByIdByUrl = new Map()
+}: DeriveEventsByIdForUrlOptions) => {
+  const eventsById: EventsById = new Map()
 
-  const addEvent = (url: string, event: TrustedEvent) => {
-    const eventsById = eventsByIdByUrl.get(url)
+  const initialize = () => {
+    const initialIds = Array.from(tracker.getIds(url))
+    const initialFilters = filters.map(assoc('ids', initialIds))
 
-    if (!eventsById?.has(event.id)) {
-      // Create a new map so we can detect which key changed
-      const newEventsById = new Map(eventsById)
-
-      newEventsById.set(event.id, event)
-      eventsByIdByUrl.set(url, newEventsById)
-
-      return true
+    for (const event of repository.query(initialFilters, {includeDeleted})) {
+      eventsById.set(event.id, event)
     }
 
-    return false
+    return eventsById
   }
 
-  const removeEvent = (url: string, id: string) => {
-    const eventsById = eventsByIdByUrl.get(url)
-
-    if (eventsById?.has(id)) {
-      eventsById.delete(id)
-
-      if (eventsById.size === 0) {
-        eventsByIdByUrl.delete(url)
-      } else {
-        // Create a new map so we can detect which key changed
-        eventsByIdByUrl.set(url, new Map(eventsById))
-      }
-
-      return true
-    }
-
-    return false
-  }
-
-  for (const event of repository.query(filters, {includeDeleted})) {
-    for (const url of tracker.getRelays(event.id)) {
-      addEvent(url, event)
-    }
-  }
-
-  return readable(eventsByIdByUrl, set => {
+  return readable(initialize(), set => {
     const unsubscribers = [
       on(repository, "update", ({added, removed}: RepositoryUpdate) => {
         let dirty = false
 
         for (const event of added) {
-          for (const url of tracker.getRelays(event.id)) {
-            dirty = dirty || addEvent(url, event)
+          if (tracker.hasRelay(event.id, url) && !eventsById.has(event.id)) {
+            eventsById.set(event.id, event)
+            dirty = true
           }
         }
 
         for (const id of removed) {
-          for (const url of tracker.getRelays(id)) {
-            dirty = dirty || removeEvent(url, id)
-          }
+          eventsById.delete(id)
+          dirty = true
         }
 
         if (dirty) {
-          set(eventsByIdByUrl)
+          set(eventsById)
         }
       }),
       on(tracker, "add", (id: string, url: string) => {
         const event = repository.getEvent(id)
 
-        if (event && addEvent(url, event)) {
-          set(eventsByIdByUrl)
+        if (event && tracker.hasRelay(id, url) && !eventsById.has(id)) {
+          eventsById.set(id, event)
+          set(eventsById)
         }
       }),
       on(tracker, "remove", (id: string, url: string) => {
-        if (removeEvent(url, id)) {
-          set(eventsByIdByUrl)
+        if (eventsById.has(id)) {
+          eventsById.delete(id)
+          set(eventsById)
         }
       }),
       on(tracker, "load", () => {
-        eventsByIdByUrl.clear()
+        eventsById.clear()
+        initialize()
 
-        for (const event of repository.query(filters, {includeDeleted})) {
-          for (const url of tracker.getRelays(event.id)) {
-            addEvent(url, event)
-          }
-        }
-
-        set(eventsByIdByUrl)
+        set(eventsById)
       }),
       on(tracker, "clear", () => {
-        eventsByIdByUrl.clear()
+        eventsById.clear()
 
-        set(eventsByIdByUrl)
+        set(eventsById)
       }),
     ]
 
@@ -166,11 +133,6 @@ export const deriveEventsByIdByUrl = ({
   })
 }
 
-export const deriveEventsByIdForUrl = (
-  url: string,
-  eventsByIdByUrlStore: Readable<EventsByIdByUrl>,
-) => deriveDeduplicated(eventsByIdByUrlStore, eventsByIdByUrl => eventsByIdByUrl.get(url))
-
 // Items by key
 
 export type ItemsByKey<T> = Map<string, T>
@@ -268,7 +230,9 @@ export const makeDeriveItem = <T>(
   itemsByKeyStore: Readable<ItemsByKey<T>>,
   onDerive?: (key: string, ...args: any[]) => void,
 ) => {
-  return (key: string, ...args: any[]) => {
+  return (key?: string, ...args: any[]) => {
+    if (!key) return readable(undefined)
+
     onDerive?.(key, ...args)
 
     return deriveDeduplicated(itemsByKeyStore, itemsByKey => itemsByKey.get(key))

packages/util/src/Relay.ts

@@ -5,7 +5,7 @@ import {last, normalizeUrl, stripProtocol} from "@welshman/lib"
 export enum RelayMode {
   Read = "read",
   Write = "write",
-  Messages = "messages",
+  Messaging = "messaging",
 }
 
 export type RelayProfile = {