@atproto/bsky 0.0.250 → 0.0.253

package/src/hydration/feed.ts

@@ -1,456 +0,0 @@
-import { dedupeStrs } from '@atproto/common'
-import { AtUriString, DidString } from '@atproto/syntax'
-import { DataPlaneClient } from '../data-plane/client/index.js'
-import { app } from '../lexicons/index.js'
-import {
-  postUriToPostgateUri,
-  postUriToThreadgateUri,
-  uriToDid as didFromUri,
-} from '../util/uris.js'
-import {
-  FeedGenRecord,
-  GateRecord,
-  LikeRecord,
-  PostRecord,
-  PostgateRecord,
-  RepostRecord,
-} from '../views/types.js'
-import {
-  HydrationMap,
-  ItemRef,
-  RecordInfo,
-  parseRecord,
-  parseString,
-  split,
-} from './util.js'
-
-export type Post = RecordInfo<PostRecord> & {
-  violatesThreadGate: boolean
-  violatesEmbeddingRules: boolean
-  hasThreadGate: boolean
-  hasPostGate: boolean
-  tags: Set<string>
-  /**
-   * Debug information for internal development
-   */
-  debug?: {
-    tags?: string[]
-  }
-}
-
-export type Posts = HydrationMap<AtUriString, Post>
-
-export type PostViewerState = {
-  like?: AtUriString
-  repost?: AtUriString
-  bookmarked?: boolean
-  threadMuted?: boolean
-}
-
-export type PostViewerStates = HydrationMap<AtUriString, PostViewerState>
-
-export type ThreadContext = {
-  // Whether the root author has liked the post.
-  like?: AtUriString
-}
-
-export type ThreadContexts = HydrationMap<AtUriString, ThreadContext>
-
-export type PostAgg = {
-  likes: number
-  replies: number
-  reposts: number
-  quotes: number
-  bookmarks: number
-}
-
-export type PostAggs = HydrationMap<AtUriString, PostAgg>
-
-export type Like = RecordInfo<LikeRecord>
-export type Likes = HydrationMap<AtUriString, Like>
-
-export type Repost = RecordInfo<RepostRecord>
-export type Reposts = HydrationMap<AtUriString, Repost>
-
-export type FeedGenAgg = {
-  likes: number
-}
-
-export type FeedGenAggs = HydrationMap<AtUriString, FeedGenAgg>
-
-export type FeedGen = RecordInfo<FeedGenRecord>
-export type FeedGens = HydrationMap<AtUriString, FeedGen>
-
-export type FeedGenViewerState = {
-  like?: AtUriString
-}
-
-export type FeedGenViewerStates = HydrationMap<AtUriString, FeedGenViewerState>
-
-export type Threadgate = RecordInfo<GateRecord>
-export type Threadgates = HydrationMap<AtUriString, Threadgate>
-export type Postgate = RecordInfo<PostgateRecord>
-export type Postgates = HydrationMap<AtUriString, Postgate>
-
-export type ThreadRef = ItemRef & { threadRoot: AtUriString }
-
-// @NOTE the feed item types in the protos for author feeds and timelines
-// technically have additional fields, not supported by the mock dataplane.
-export type FeedItem = {
-  post: ItemRef
-  repost?: ItemRef
-  /**
-   * If true, overrides the `reason` with `app.bsky.feed.defs#reasonPin`. Used
-   * only in author feeds.
-   */
-  authorPinned?: boolean
-}
-
-export type GetPostsHydrationOptions = {
-  processDynamicTagsForView?: 'thread' | 'search'
-}
-
-export class FeedHydrator {
-  constructor(public dataplane: DataPlaneClient) {}
-
-  async getPosts(
-    uris: AtUriString[],
-    includeTakedowns = false,
-    given: Posts = new HydrationMap(),
-    viewer?: string | null,
-    options: GetPostsHydrationOptions = {},
-  ): Promise<Posts> {
-    const [have, need] = split(uris, (uri) => given.has(uri))
-    const base: Posts = new HydrationMap()
-
-    for (const uri of have) {
-      base.set(uri, given.get(uri) ?? null)
-    }
-
-    if (need.length) {
-      const res = await this.dataplane.getPostRecords(
-        options.processDynamicTagsForView
-          ? {
-              uris: need,
-              viewerDid: viewer ?? undefined,
-              processDynamicTagsForView: options.processDynamicTagsForView,
-            }
-          : {
-              uris: need,
-            },
-      )
-
-      for (let i = 0; i < need.length; i++) {
-        const record = parseRecord(
-          app.bsky.feed.post.main,
-          res.records[i],
-          includeTakedowns,
-        )
-        const violatesThreadGate = res.meta[i].violatesThreadGate
-        const violatesEmbeddingRules = res.meta[i].violatesEmbeddingRules
-        const hasThreadGate = res.meta[i].hasThreadGate
-        const hasPostGate = res.meta[i].hasPostGate
-        const tags = new Set<string>(res.records[i].tags ?? [])
-        const debug = { tags: Array.from(tags) }
-
-        base.set(
-          need[i],
-          record
-            ? {
-                ...record,
-                violatesThreadGate,
-                violatesEmbeddingRules,
-                hasThreadGate,
-                hasPostGate,
-                tags,
-                debug,
-              }
-            : null,
-        )
-      }
-    }
-
-    return base
-  }
-
-  async getPostViewerStates(
-    refs: ThreadRef[],
-    viewer: string,
-  ): Promise<PostViewerStates> {
-    const map: PostViewerStates = new HydrationMap()
-    if (!refs.length) return map
-
-    const [likes, reposts, bookmarks, threadMutesMap] = await Promise.all([
-      this.dataplane.getLikesByActorAndSubjects({
-        actorDid: viewer,
-        refs,
-      }),
-      this.dataplane.getRepostsByActorAndSubjects({
-        actorDid: viewer,
-        refs,
-      }),
-      this.dataplane.getBookmarksByActorAndSubjects({
-        actorDid: viewer,
-        uris: refs.map((r) => r.uri),
-      }),
-      this.getThreadMutes(
-        refs.map((r) => r.threadRoot),
-        viewer,
-      ),
-    ])
-
-    for (let i = 0; i < refs.length; i++) {
-      const { uri, threadRoot } = refs[i]
-      map.set(uri, {
-        like: parseString(likes.uris[i]),
-        repost: parseString(reposts.uris[i]),
-        // @NOTE: The dataplane contract is that the array position will be present,
-        // but the optional chaining is to ensure it works regardless of the dataplane being update to provide the data.
-        bookmarked: !!bookmarks.bookmarks.at(i)?.ref?.key,
-        threadMuted: threadMutesMap.get(threadRoot) ?? false,
-      })
-    }
-
-    return map
-  }
-
-  private async getThreadMutes(
-    threadRoots: AtUriString[],
-    viewer: string,
-  ): Promise<Map<string, boolean>> {
-    const deduped = dedupeStrs(threadRoots)
-    const threadMutes = await this.dataplane.getThreadMutesOnSubjects({
-      actorDid: viewer,
-      threadRoots: deduped,
-    })
-    const map: Map<AtUriString, boolean> = new Map()
-    for (let i = 0; i < deduped.length; i++) {
-      map.set(deduped[i], threadMutes.muted[i] ?? false)
-    }
-
-    return map
-  }
-
-  async getThreadContexts(refs: ThreadRef[]): Promise<ThreadContexts> {
-    const map: ThreadContexts = new HydrationMap()
-    if (!refs.length) return map
-
-    const refsByRootAuthor = new Map<DidString, ThreadRef[]>()
-
-    for (const ref of refs) {
-      const { threadRoot } = ref
-      const rootAuthor = didFromUri(threadRoot)
-      const existingValue = refsByRootAuthor.get(rootAuthor) ?? []
-      refsByRootAuthor.set(rootAuthor, [...existingValue, ref])
-    }
-
-    const refsByRootAuthorEntries = Array.from(refsByRootAuthor.entries())
-
-    const rootAuthorsLikes = await Promise.all(
-      refsByRootAuthorEntries.map(([rootAuthor, refsForAuthor]) =>
-        this.dataplane.getLikesByActorAndSubjects({
-          actorDid: rootAuthor,
-          refs: refsForAuthor.map(({ uri, cid }) => ({ uri, cid })),
-        }),
-      ),
-    )
-
-    const likesByUri = new Map<AtUriString, AtUriString>()
-
-    for (let i = 0; i < refsByRootAuthorEntries.length; i++) {
-      const [_rootAuthor, refsForAuthor] = refsByRootAuthorEntries[i]
-      const likesForRootAuthor = rootAuthorsLikes[i]
-      for (let j = 0; j < refsForAuthor.length; j++) {
-        const { uri } = refsForAuthor[j]
-        likesByUri.set(uri, likesForRootAuthor.uris[j] as AtUriString)
-      }
-    }
-
-    for (const { uri } of refs) {
-      map.set(uri, {
-        like: parseString(likesByUri.get(uri)),
-      })
-    }
-
-    return map
-  }
-
-  async getPostAggregates(
-    refs: ItemRef[],
-    viewer: DidString | null,
-  ): Promise<PostAggs> {
-    const map: PostAggs = new HydrationMap()
-    if (!refs.length) return map
-
-    const counts = await this.dataplane.getInteractionCounts({
-      refs,
-      skipCacheForDids: viewer ? [viewer] : undefined,
-    })
-
-    for (let i = 0; i < refs.length; i++) {
-      map.set(refs[i].uri, {
-        likes: counts.likes[i] ?? 0,
-        replies: counts.replies[i] ?? 0,
-        reposts: counts.reposts[i] ?? 0,
-        quotes: counts.quotes[i] ?? 0,
-        bookmarks: counts.bookmarks[i] ?? 0,
-      })
-    }
-
-    return map
-  }
-
-  async getFeedGens(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<FeedGens> {
-    const map: FeedGens = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getFeedGeneratorRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const record = parseRecord(
-        app.bsky.feed.generator.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uris[i], record ?? null)
-    }
-
-    return map
-  }
-
-  async getFeedGenViewerStates(
-    uris: AtUriString[],
-    viewer: DidString,
-  ): Promise<FeedGenViewerStates> {
-    const map: FeedGenViewerStates = new HydrationMap()
-    if (!uris.length) return map
-
-    const likes = await this.dataplane.getLikesByActorAndSubjects({
-      actorDid: viewer,
-      refs: uris.map((uri) => ({ uri })),
-    })
-    for (let i = 0; i < uris.length; i++) {
-      map.set(uris[i], {
-        like: parseString(likes.uris[i]),
-      })
-    }
-
-    return map
-  }
-
-  async getFeedGenAggregates(
-    refs: ItemRef[],
-    viewer: DidString | null,
-  ): Promise<FeedGenAggs> {
-    const map: FeedGenAggs = new HydrationMap()
-    if (!refs.length) return map
-
-    const counts = await this.dataplane.getInteractionCounts({
-      refs,
-      skipCacheForDids: viewer ? [viewer] : undefined,
-    })
-    for (let i = 0; i < refs.length; i++) {
-      map.set(refs[i].uri, { likes: counts.likes[i] ?? 0 })
-    }
-
-    return map
-  }
-
-  async getThreadgatesForPosts(
-    postUris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Threadgates> {
-    const uris = postUris.map(postUriToThreadgateUri)
-    return this.getThreadgateRecords(uris, includeTakedowns)
-  }
-
-  async getThreadgateRecords(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Threadgates> {
-    const map: Threadgates = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getThreadGateRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const record = parseRecord(
-        app.bsky.feed.threadgate.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uris[i], record ?? null)
-    }
-
-    return map
-  }
-
-  async getPostgatesForPosts(
-    postUris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Postgates> {
-    const uris = postUris.map(postUriToPostgateUri)
-    return this.getPostgateRecords(uris, includeTakedowns)
-  }
-
-  async getPostgateRecords(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Postgates> {
-    const map: Postgates = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getPostgateRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const record = parseRecord(
-        app.bsky.feed.postgate.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uris[i], record ?? null)
-    }
-
-    return map
-  }
-
-  async getLikes(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Likes> {
-    const map: Likes = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getLikeRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const record = parseRecord(
-        app.bsky.feed.like.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uris[i], record ?? null)
-    }
-
-    return map
-  }
-
-  async getReposts(
-    uris: AtUriString[],
-    includeTakedowns = false,
-  ): Promise<Reposts> {
-    const map: Reposts = new HydrationMap()
-    if (!uris.length) return map
-
-    const res = await this.dataplane.getRepostRecords({ uris })
-    for (let i = 0; i < uris.length; i++) {
-      const record = parseRecord(
-        app.bsky.feed.repost.main,
-        res.records[i],
-        includeTakedowns,
-      )
-      map.set(uris[i], record ?? null)
-    }
-
-    return map
-  }
-}