forked from coracle/flotilla
Jon Staab
460 lines
14 KiB
TypeScript
460 lines
14 KiB
TypeScript
import type {Readable} from "svelte/store"
|
|
import {writable, readable, derived} from "svelte/store"
|
|
import type {Maybe} from "@welshman/lib"
|
|
import {uniq, uniqBy, groupBy, pushToMapKey, nthEq, batcher, postJson, stripProtocol, assoc, indexBy, now} from "@welshman/lib"
|
|
import {getIdentifier, getRelayTags, getRelayTagValues, normalizeRelayUrl, getPubkeyTagValues, GROUP_META, PROFILE, RELAYS, FOLLOWS, MUTES, GROUPS, getGroupTags, readProfile, readList, asDecryptedEvent, editList, makeList, createList} from "@welshman/util"
|
|
import type {Filter, SignedEvent, CustomEvent, PublishedProfile, PublishedList} from '@welshman/util'
|
|
import {publish, subscribe} from '@welshman/net'
|
|
import {decrypt} from '@welshman/signer'
|
|
import {deriveEvents, deriveEventsMapped, getter, withGetter} from "@welshman/store"
|
|
import {synced, parseJson} from '@lib/util'
|
|
import type {Session, Handle, Relay} from '@app/types'
|
|
import {INDEXER_RELAYS, DUFFLEPUD_URL, repository, pk, getPk, getSessions, makeSigner, getSigner} from "@app/base"
|
|
|
|
// Utils
|
|
|
|
export const createCollection = <T>({
|
|
store,
|
|
getKey,
|
|
isStale,
|
|
load,
|
|
}: {
|
|
store: Readable<T[]>,
|
|
getKey: (item: T) => string,
|
|
isStale: (item: T) => boolean,
|
|
load: (key: string, ...args: any) => Promise<any>
|
|
}) => {
|
|
const indexStore = derived(store, $items => indexBy(getKey, $items))
|
|
const getIndex = getter(indexStore)
|
|
|
|
const getItem = (key: string) => getIndex().get(key)
|
|
|
|
const loadItem = async (key: string, ...args: any[]) => {
|
|
const item = getIndex().get(key)
|
|
|
|
if (item && !isStale(item)) {
|
|
return item
|
|
}
|
|
|
|
await load(key, ...args)
|
|
|
|
return getIndex().get(key)
|
|
}
|
|
|
|
const deriveItem = (key: Maybe<string>, ...args: any[]) => {
|
|
if (!key) {
|
|
return readable(undefined)
|
|
}
|
|
|
|
// If we don't yet have the item, or it's stale, trigger a request for it. The derived
|
|
// store will update when it arrives
|
|
load(key, ...args)
|
|
|
|
return derived(indexStore, $index => $index.get(key))
|
|
}
|
|
|
|
return {indexStore, getIndex, deriveItem, loadItem, getItem}
|
|
}
|
|
|
|
export const load = ({relays, filters}: {relays: string[], filters: Filter[]}) =>
|
|
new Promise<Maybe<CustomEvent>>(resolve => {
|
|
const sub = subscribe({relays, filters, closeOnEose: true, timeout: 3000})
|
|
|
|
sub.emitter.on('event', (url: string, event: SignedEvent) => {
|
|
const e: CustomEvent = {...event, fetched_at: now()}
|
|
|
|
repository.publish(e)
|
|
resolve(e)
|
|
})
|
|
|
|
sub.emitter.on('complete', () => resolve(undefined))
|
|
})
|
|
|
|
export type ModifyTags = (tags: string[][]) => string[][]
|
|
|
|
export const updateList = async (kind: number, modifyTags: ModifyTags) => {
|
|
const pk = getPk()!
|
|
const signer = getSigner()!
|
|
const [prev] = repository.query([{kinds: [kind], authors: [pk]}])
|
|
|
|
// Preserve content instead of use encrypted tags because kind 3 content is used for
|
|
// relay selections in many places. Content isn't supported for mutes or relays so this is ok
|
|
const relays = [...INDEXER_RELAYS, ...getWriteRelayUrls(getRelaySelections(pk))]
|
|
const encrypt = (content: string) => signer.nip44.encrypt(pk, content)
|
|
|
|
let encryptable
|
|
if (prev) {
|
|
const content = await ensurePlaintext(prev)
|
|
const list = readList(asDecryptedEvent(prev, {content}))
|
|
const publicTags = modifyTags(list.publicTags)
|
|
|
|
encryptable = editList({...list, publicTags})
|
|
} else {
|
|
const list = makeList({kind})
|
|
const publicTags = modifyTags(list.publicTags)
|
|
|
|
encryptable = createList({...list, publicTags})
|
|
}
|
|
|
|
const template = await encryptable.reconcile(encrypt)
|
|
const event = await signer.sign({...template, created_at: now()})
|
|
|
|
await publish({event, relays})
|
|
}
|
|
|
|
// Plaintext
|
|
|
|
export const plaintext = withGetter(writable<Record<string, string>>({}))
|
|
|
|
export const getPlaintext = (e: CustomEvent) => plaintext.get()[e.id]
|
|
|
|
export const setPlaintext = (e: CustomEvent, content: string) =>
|
|
plaintext.update(assoc(e.id, content))
|
|
|
|
export const ensurePlaintext = async (e: CustomEvent) => {
|
|
if (e.content && !getPlaintext(e)) {
|
|
const sessions = getSessions()
|
|
const session = sessions[e.pubkey]
|
|
const signer = makeSigner(session)
|
|
|
|
if (signer) {
|
|
setPlaintext(e, await decrypt(signer, e.pubkey, e.content))
|
|
}
|
|
}
|
|
|
|
return getPlaintext(e)
|
|
}
|
|
|
|
// Relay info
|
|
|
|
export const relays = writable<Relay[]>([])
|
|
|
|
export const relaysByPubkey = derived(relays, $relays => groupBy(($relay: Relay) => $relay.pubkey, $relays))
|
|
|
|
export const {
|
|
indexStore: relaysByUrl,
|
|
getIndex: getRelaysByUrl,
|
|
deriveItem: deriveRelay,
|
|
loadItem: loadRelay,
|
|
getItem: getRelay,
|
|
} = createCollection({
|
|
store: relays,
|
|
getKey: (relay: Relay) => relay.url,
|
|
isStale: (relay: Relay) => relay.fetched_at < now() - 3600,
|
|
load: batcher(800, async (urls: string[]) => {
|
|
const urlSet = new Set(urls)
|
|
const res = await postJson(`${DUFFLEPUD_URL}/relay/info`, {urls: Array.from(urlSet)})
|
|
const index = indexBy((item: any) => item.url, res?.data || [])
|
|
const items: Relay[] = urls.map(url => {
|
|
const {info = {}} = index.get(url) || {}
|
|
|
|
return {...info, url, fetched_at: now()}
|
|
})
|
|
|
|
relays.update($relays => uniqBy($relay => $relay.url, [...$relays, ...items]))
|
|
|
|
return items
|
|
}),
|
|
})
|
|
|
|
// Handles
|
|
|
|
export const handles = writable<Handle[]>([])
|
|
|
|
export const {
|
|
indexStore: handlesByPubkey,
|
|
getIndex: getHandlesByPubkey,
|
|
deriveItem: deriveHandle,
|
|
loadItem: loadHandle,
|
|
getItem: getHandle,
|
|
} = createCollection({
|
|
store: handles,
|
|
getKey: (handle: Handle) => handle.pubkey,
|
|
isStale: (handle: Handle) => handle.fetched_at < now() - 3600,
|
|
load: batcher(800, async (nip05s: string[]) => {
|
|
const nip05Set = new Set(nip05s)
|
|
const res = await postJson(`${DUFFLEPUD_URL}/handle/info`, {handles: Array.from(nip05Set)})
|
|
const index = indexBy((item: any) => item.handle, res?.data || [])
|
|
const items: Handle[] = nip05s.map(nip05 => {
|
|
const {info = {}} = index.get(nip05) || {}
|
|
|
|
return {...info, nip05, fetched_at: now()}
|
|
})
|
|
|
|
handles.update($handles => uniqBy($handle => $handle.nip05, [...$handles, ...items]))
|
|
|
|
return items
|
|
}),
|
|
})
|
|
|
|
// Profiles
|
|
|
|
export const profiles = deriveEventsMapped<PublishedProfile>({
|
|
repository,
|
|
filters: [{kinds: [PROFILE]}],
|
|
eventToItem: readProfile,
|
|
itemToEvent: item => item.event,
|
|
})
|
|
|
|
export const {
|
|
indexStore: profilesByPubkey,
|
|
getIndex: getProfilesByPubkey,
|
|
deriveItem: deriveProfile,
|
|
loadItem: loadProfile,
|
|
getItem: getProfile,
|
|
} = createCollection({
|
|
store: profiles,
|
|
getKey: profile => profile.event.pubkey,
|
|
isStale: (profile: PublishedProfile) => profile.event.fetched_at < now() - 3600,
|
|
load: (pubkey: string, relays = []) =>
|
|
load({
|
|
relays: [...relays, ...INDEXER_RELAYS],
|
|
filters: [{kinds: [PROFILE], authors: [pubkey]}],
|
|
}),
|
|
})
|
|
|
|
// Relay selections
|
|
|
|
export const getReadRelayUrls = (event?: CustomEvent): string[] =>
|
|
getRelayTags(event?.tags || []).filter((t: string[]) => !t[2] || t[2] === 'read').map((t: string[]) => normalizeRelayUrl(t[1]))
|
|
|
|
export const getWriteRelayUrls = (event?: CustomEvent): string[] =>
|
|
getRelayTags(event?.tags || []).filter((t: string[]) => !t[2] || t[2] === 'write').map((t: string[]) => normalizeRelayUrl(t[1]))
|
|
|
|
export const relaySelections = deriveEvents({repository, filters: [{kinds: [RELAYS]}]})
|
|
|
|
export const {
|
|
indexStore: relaySelectionsByPubkey,
|
|
getIndex: getRelaySelectionsByPubkey,
|
|
deriveItem: deriveRelaySelections,
|
|
loadItem: loadRelaySelections,
|
|
getItem: getRelaySelections,
|
|
} = createCollection({
|
|
store: relaySelections,
|
|
getKey: relaySelections => relaySelections.pubkey,
|
|
isStale: (relaySelections: CustomEvent) => relaySelections.fetched_at < now() - 3600,
|
|
load: (pubkey: string, relays = []) =>
|
|
load({
|
|
relays: [...relays, ...INDEXER_RELAYS],
|
|
filters: [{kinds: [RELAYS], authors: [pubkey]}],
|
|
})
|
|
})
|
|
|
|
// Follows
|
|
|
|
export const follows = deriveEventsMapped<PublishedList>({
|
|
repository,
|
|
filters: [{kinds: [FOLLOWS]}],
|
|
itemToEvent: item => item.event,
|
|
eventToItem: async (event: CustomEvent) =>
|
|
readList(
|
|
asDecryptedEvent(event, {
|
|
content: await ensurePlaintext(event),
|
|
}),
|
|
),
|
|
})
|
|
|
|
export const {
|
|
indexStore: followsByPubkey,
|
|
getIndex: getFollowsByPubkey,
|
|
deriveItem: deriveFollows,
|
|
loadItem: loadFollows,
|
|
getItem: getFollows,
|
|
} = createCollection({
|
|
store: follows,
|
|
getKey: follows => follows.event.pubkey,
|
|
isStale: (follows: PublishedList) => follows.event.fetched_at < now() - 3600,
|
|
load: (pubkey: string, relays = []) =>
|
|
load({
|
|
relays: [...relays, ...INDEXER_RELAYS],
|
|
filters: [{kinds: [FOLLOWS], authors: [pubkey]}],
|
|
})
|
|
})
|
|
|
|
// Mutes
|
|
|
|
export const mutes = deriveEventsMapped<PublishedList>({
|
|
repository,
|
|
filters: [{kinds: [MUTES]}],
|
|
itemToEvent: item => item.event,
|
|
eventToItem: async (event: CustomEvent) =>
|
|
readList(
|
|
asDecryptedEvent(event, {
|
|
content: await ensurePlaintext(event),
|
|
}),
|
|
),
|
|
})
|
|
|
|
export const {
|
|
indexStore: mutesByPubkey,
|
|
getIndex: getMutesByPubkey,
|
|
deriveItem: deriveMutes,
|
|
loadItem: loadMutes,
|
|
getItem: getMutes,
|
|
} = createCollection({
|
|
store: mutes,
|
|
getKey: mute => mute.event.pubkey,
|
|
isStale: (mutes: PublishedList) => mutes.event.fetched_at < now() - 3600,
|
|
load: (pubkey: string, relays = []) =>
|
|
load({
|
|
relays: [...relays, ...INDEXER_RELAYS],
|
|
filters: [{kinds: [MUTES], authors: [pubkey]}],
|
|
})
|
|
})
|
|
|
|
// Groups
|
|
|
|
export const GROUP_DELIMITER = `'`
|
|
|
|
export const makeGroupId = (url: string, nom: string) =>
|
|
[stripProtocol(url).replace(/\/$/, ''), nom].join(GROUP_DELIMITER)
|
|
|
|
export const splitGroupId = (groupId: string) => {
|
|
const [url, nom] = groupId.split(GROUP_DELIMITER)
|
|
|
|
return [normalizeRelayUrl(url), nom]
|
|
}
|
|
|
|
export const getGroupUrl = (groupId: string) => splitGroupId(groupId)[0]
|
|
|
|
export const getGroupNom = (groupId: string) => splitGroupId(groupId)[1]
|
|
|
|
export const getGroupName = (e?: CustomEvent) => e?.tags.find(nthEq(0, "name"))?.[1]
|
|
|
|
export const getGroupPicture = (e?: CustomEvent) => e?.tags.find(nthEq(0, "picture"))?.[1]
|
|
|
|
export type Group = {
|
|
nom: string,
|
|
name?: string,
|
|
picture?: string,
|
|
event?: CustomEvent
|
|
}
|
|
|
|
export type PublishedGroup = Omit<Group, "event"> & {
|
|
event: CustomEvent
|
|
}
|
|
|
|
export const readGroup = (event: CustomEvent) => {
|
|
const nom = getIdentifier(event)!
|
|
const name = event?.tags.find(nthEq(0, "name"))?.[1]
|
|
const picture = event?.tags.find(nthEq(0, "picture"))?.[1]
|
|
|
|
return {nom, name, picture, event}
|
|
}
|
|
|
|
export const groups = deriveEventsMapped<PublishedGroup>({
|
|
repository,
|
|
filters: [{kinds: [GROUP_META]}],
|
|
eventToItem: readGroup,
|
|
itemToEvent: item => item.event,
|
|
})
|
|
|
|
export const {
|
|
indexStore: groupsByNom,
|
|
getIndex: getGroupsByNom,
|
|
deriveItem: deriveGroup,
|
|
loadItem: loadGroup,
|
|
getItem: getGroup,
|
|
} = createCollection({
|
|
store: groups,
|
|
getKey: (group: PublishedGroup) => group.nom,
|
|
isStale: (group: PublishedGroup) => group.event.fetched_at < now() - 3600,
|
|
load: (nom: string, relays: string[] = []) =>
|
|
Promise.all([
|
|
...relays.map(loadRelay),
|
|
load({
|
|
relays,
|
|
filters: [{kinds: [GROUP_META], '#d': [nom]}],
|
|
}),
|
|
])
|
|
})
|
|
|
|
// Qualified groups
|
|
|
|
export type QualifiedGroup = {
|
|
id: string
|
|
relay: Relay
|
|
group: PublishedGroup
|
|
}
|
|
|
|
export const qualifiedGroups = derived([relaysByPubkey, groups], ([$relaysByPubkey, $groups]) =>
|
|
$groups.flatMap((group: PublishedGroup) => {
|
|
const relays = $relaysByPubkey.get(group.event.pubkey) || []
|
|
|
|
return relays.map(relay => ({id: makeGroupId(relay.url, group.nom), relay, group}))
|
|
})
|
|
)
|
|
|
|
export const qualifiedGroupsById = derived(qualifiedGroups, $qualifiedGroups => indexBy($qg => $qg.id, $qualifiedGroups))
|
|
|
|
// Group membership
|
|
|
|
export type GroupMembership = {
|
|
ids: Set<string>
|
|
noms: Set<string>
|
|
urls: Set<string>
|
|
event?: CustomEvent
|
|
}
|
|
|
|
export type PublishedGroupMembership = Omit<GroupMembership, "event"> & {
|
|
event: CustomEvent
|
|
}
|
|
|
|
export const readGroupMembership = (event: CustomEvent) => {
|
|
const ids = new Set<string>()
|
|
const noms = new Set<string>()
|
|
const urls = new Set<string>()
|
|
|
|
for (const [_, nom, url] of getGroupTags(event.tags)) {
|
|
ids.add(makeGroupId(url, nom))
|
|
noms.add(nom)
|
|
urls.add(url)
|
|
}
|
|
|
|
return {event, ids, noms, urls}
|
|
}
|
|
|
|
export const groupMemberships = deriveEventsMapped<PublishedGroupMembership>({
|
|
repository,
|
|
filters: [{kinds: [GROUPS]}],
|
|
eventToItem: readGroupMembership,
|
|
itemToEvent: item => item.event,
|
|
})
|
|
|
|
export const {
|
|
indexStore: groupMembershipsByPubkey,
|
|
getIndex: getGroupMembersipsByPubkey,
|
|
deriveItem: deriveGroupMembership,
|
|
loadItem: loadGroupMembership,
|
|
getItem: getGroupMembership,
|
|
} = createCollection({
|
|
store: groupMemberships,
|
|
getKey: groupMembership => groupMembership.event.pubkey,
|
|
isStale: (groupMembership: PublishedGroupMembership) => groupMembership.event.fetched_at < now() - 3600,
|
|
load: (pubkey: string, relays = []) =>
|
|
load({
|
|
relays: [...relays, ...INDEXER_RELAYS],
|
|
filters: [{kinds: [GROUPS], authors: [pubkey]}],
|
|
})
|
|
})
|
|
|
|
// User stuff
|
|
|
|
export const loadUserData = async (pubkey: string, hints: string[] = []) => {
|
|
const relaySelections = await loadRelaySelections(pubkey, INDEXER_RELAYS)
|
|
const relays = uniq([...getRelayTagValues(relaySelections?.tags || []), ...INDEXER_RELAYS, ...hints])
|
|
|
|
const [membership] = await Promise.all([
|
|
loadGroupMembership(pubkey, relays),
|
|
loadProfile(pubkey, relays),
|
|
loadFollows(pubkey, relays),
|
|
loadMutes(pubkey, relays),
|
|
])
|
|
|
|
if (membership) {
|
|
await Promise.all(
|
|
getGroupTags(membership.event.tags).map(([_, nom, url]) => loadGroup(nom, [url]))
|
|
)
|
|
}
|
|
}
|