@atproto/bsky 0.0.15 → 0.0.17

package/src/services/actor/index.ts

@@ -1,27 +1,37 @@
 import { sql } from 'kysely'
+import { wait } from '@atproto/common'
 import { Database } from '../../db'
 import { notSoftDeletedClause } from '../../db/util'
 import { ActorViews } from './views'
 import { ImageUriBuilder } from '../../image/uri'
 import { Actor } from '../../db/tables/actor'
-import { LabelCache } from '../../label-cache'
 import { TimeCidKeyset, paginate } from '../../db/pagination'
 import { SearchKeyset, getUserSearchQuery } from '../util/search'
+import { FromDb } from '../types'
+import { GraphService } from '../graph'
+import { LabelService } from '../label'
 
 export * from './types'
 
 export class ActorService {
+  views: ActorViews
+
   constructor(
     public db: Database,
     public imgUriBuilder: ImageUriBuilder,
-    public labelCache: LabelCache,
-  ) {}
-
-  static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache) {
-    return (db: Database) => new ActorService(db, imgUriBuilder, labelCache)
+    private graph: FromDb<GraphService>,
+    private label: FromDb<LabelService>,
+  ) {
+    this.views = new ActorViews(this.db, this.imgUriBuilder, graph, label)
   }
 
-  views = new ActorViews(this.db, this.imgUriBuilder, this.labelCache)
+  static creator(
+    imgUriBuilder: ImageUriBuilder,
+    graph: FromDb<GraphService>,
+    label: FromDb<LabelService>,
+  ) {
+    return (db: Database) => new ActorService(db, imgUriBuilder, graph, label)
+  }
 
   async getActorDid(handleOrDid: string): Promise<string | null> {
     if (handleOrDid.startsWith('did:')) {
@@ -144,6 +154,44 @@ export class ActorService {
       .executeTakeFirst()
     return res?.repoRev ?? null
   }
+
+  async *all(
+    opts: {
+      batchSize?: number
+      forever?: boolean
+      cooldownMs?: number
+      startFromDid?: string
+    } = {},
+  ) {
+    const {
+      cooldownMs = 1000,
+      batchSize = 1000,
+      forever = false,
+      startFromDid,
+    } = opts
+    const baseQuery = this.db.db
+      .selectFrom('actor')
+      .selectAll()
+      .orderBy('did')
+      .limit(batchSize)
+    while (true) {
+      let cursor = startFromDid
+      do {
+        const actors = cursor
+          ? await baseQuery.where('did', '>', cursor).execute()
+          : await baseQuery.execute()
+        for (const actor of actors) {
+          yield actor
+        }
+        cursor = actors.at(-1)?.did
+      } while (cursor)
+      if (forever) {
+        await wait(cooldownMs)
+      } else {
+        return
+      }
+    }
+  }
 }
 
 type ActorResult = Actor

package/src/services/actor/views.ts

@@ -11,7 +11,6 @@ import { Actor } from '../../db/tables/actor'
 import { ImageUriBuilder } from '../../image/uri'
 import { LabelService, Labels, getSelfLabels } from '../label'
 import { BlockAndMuteState, GraphService } from '../graph'
-import { LabelCache } from '../../label-cache'
 import {
   ActorInfoMap,
   ProfileDetailHydrationState,
@@ -21,17 +20,24 @@ import {
   toMapByDid,
 } from './types'
 import { ListInfoMap } from '../graph/types'
+import { FromDb } from '../types'
 
 export class ActorViews {
+  services: {
+    label: LabelService
+    graph: GraphService
+  }
+
   constructor(
     private db: Database,
     private imgUriBuilder: ImageUriBuilder,
-    private labelCache: LabelCache,
-  ) {}
-
-  services = {
-    label: LabelService.creator(this.labelCache)(this.db),
-    graph: GraphService.creator(this.imgUriBuilder)(this.db),
+    private graph: FromDb<GraphService>,
+    private label: FromDb<LabelService>,
+  ) {
+    this.services = {
+      label: label(db),
+      graph: graph(db),
+    }
   }
 
   async profiles(
@@ -45,10 +51,7 @@ export class ActorViews {
       viewer,
       ...opts,
     })
-    return this.profilePresentation(dids, hydrated, {
-      viewer,
-      ...opts,
-    })
+    return this.profilePresentation(dids, hydrated, viewer)
   }
 
   async profilesBasic(
@@ -62,10 +65,7 @@ export class ActorViews {
       viewer,
       includeSoftDeleted: opts?.includeSoftDeleted,
     })
-    return this.profileBasicPresentation(dids, hydrated, {
-      viewer,
-      omitLabels: opts?.omitLabels,
-    })
+    return this.profileBasicPresentation(dids, hydrated, viewer, opts)
   }
 
   async profilesList(
@@ -293,11 +293,8 @@ export class ActorViews {
       labels: Labels
       bam: BlockAndMuteState
     },
-    opts?: {
-      viewer?: string | null
-    },
+    viewer: string | null,
   ): ProfileViewMap {
-    const { viewer } = opts ?? {}
     const { profiles, lists, labels, bam } = state
     return dids.reduce((acc, did) => {
       const prof = profiles[did]
@@ -357,12 +354,12 @@ export class ActorViews {
   profileBasicPresentation(
     dids: string[],
     state: ProfileHydrationState,
+    viewer: string | null,
     opts?: {
-      viewer?: string | null
       omitLabels?: boolean
     },
   ): ProfileViewMap {
-    const result = this.profilePresentation(dids, state, opts)
+    const result = this.profilePresentation(dids, state, viewer)
     return Object.values(result).reduce((acc, prof) => {
       const profileBasic = {
         did: prof.did,

package/src/services/feed/index.ts

@@ -1,6 +1,7 @@
 import { sql } from 'kysely'
 import { AtUri } from '@atproto/syntax'
 import { jsonStringToLex } from '@atproto/lexicon'
+import { mapDefined } from '@atproto/common'
 import { Database } from '../../db'
 import { countAll, noMatch, notSoftDeletedClause } from '../../db/util'
 import { ImageUriBuilder } from '../../image/uri'
@@ -42,28 +43,42 @@ import {
   RelationshipPair,
 } from '../graph'
 import { FeedViews } from './views'
-import { LabelCache } from '../../label-cache'
 import { threadgateToPostUri, postToThreadgateUri } from './util'
+import { FromDb } from '../types'
 
 export * from './types'
 
 export class FeedService {
+  views: FeedViews
+  services: {
+    label: LabelService
+    actor: ActorService
+    graph: GraphService
+  }
+
   constructor(
     public db: Database,
     public imgUriBuilder: ImageUriBuilder,
-    public labelCache: LabelCache,
-  ) {}
-
-  views = new FeedViews(this.db, this.imgUriBuilder, this.labelCache)
-
-  services = {
-    label: LabelService.creator(this.labelCache)(this.db),
-    actor: ActorService.creator(this.imgUriBuilder, this.labelCache)(this.db),
-    graph: GraphService.creator(this.imgUriBuilder)(this.db),
+    private actor: FromDb<ActorService>,
+    private label: FromDb<LabelService>,
+    private graph: FromDb<GraphService>,
+  ) {
+    this.views = new FeedViews(this.db, this.imgUriBuilder, actor, graph)
+    this.services = {
+      label: label(this.db),
+      actor: actor(this.db),
+      graph: graph(this.db),
+    }
   }
 
-  static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache) {
-    return (db: Database) => new FeedService(db, imgUriBuilder, labelCache)
+  static creator(
+    imgUriBuilder: ImageUriBuilder,
+    actor: FromDb<ActorService>,
+    label: FromDb<LabelService>,
+    graph: FromDb<GraphService>,
+  ) {
+    return (db: Database) =>
+      new FeedService(db, imgUriBuilder, actor, label, graph)
   }
 
   selectPostQb() {
@@ -205,6 +220,11 @@ export class FeedService {
     }, {} as Record<string, FeedRow>)
   }
 
+  async postUrisToFeedItems(uris: string[]): Promise<FeedRow[]> {
+    const feedItems = await this.getFeedItems(uris)
+    return mapDefined(uris, (uri) => feedItems[uri])
+  }
+
   feedItemRefs(items: FeedRow[]) {
     const actorDids = new Set<string>()
     const postUris = new Set<string>()
@@ -399,20 +419,32 @@ export class FeedService {
     const actorInfos = this.services.actor.views.profileBasicPresentation(
       [...nestedDids],
       feedState,
-      { viewer },
+      viewer,
     )
     const recordEmbedViews: RecordEmbedViewRecordMap = {}
     for (const uri of nestedUris) {
       const collection = new AtUri(uri).collection
       if (collection === ids.AppBskyFeedGenerator && feedGenInfos[uri]) {
-        recordEmbedViews[uri] = {
-          $type: 'app.bsky.feed.defs#generatorView',
-          ...this.views.formatFeedGeneratorView(feedGenInfos[uri], actorInfos),
+        const genView = this.views.formatFeedGeneratorView(
+          feedGenInfos[uri],
+          actorInfos,
+        )
+        if (genView) {
+          recordEmbedViews[uri] = {
+            $type: 'app.bsky.feed.defs#generatorView',
+            ...genView,
+          }
         }
       } else if (collection === ids.AppBskyGraphList && listViews[uri]) {
-        recordEmbedViews[uri] = {
-          $type: 'app.bsky.graph.defs#listView',
-          ...this.services.graph.formatListView(listViews[uri], actorInfos),
+        const listView = this.services.graph.formatListView(
+          listViews[uri],
+          actorInfos,
+        )
+        if (listView) {
+          recordEmbedViews[uri] = {
+            $type: 'app.bsky.graph.defs#listView',
+            ...listView,
+          }
         }
       } else if (collection === ids.AppBskyFeedPost && feedState.posts[uri]) {
         const formatted = this.views.formatPostView(
@@ -423,6 +455,7 @@ export class FeedService {
           feedState.embeds,
           feedState.labels,
           feedState.lists,
+          viewer,
         )
         recordEmbedViews[uri] = this.views.getRecordEmbedView(
           uri,

package/src/services/feed/util.ts

@@ -36,43 +36,72 @@ export const invalidReplyRoot = (
   return parent.record.reply?.root.uri !== replyRoot
 }
 
-export const violatesThreadGate = async (
-  db: DatabaseSchema,
-  did: string,
-  owner: string,
-  root: PostRecord | null,
+type ParsedThreadGate = {
+  canReply?: boolean
+  allowMentions?: boolean
+  allowFollowing?: boolean
+  allowListUris?: string[]
+}
+
+export const parseThreadGate = (
+  replierDid: string,
+  ownerDid: string,
+  rootPost: PostRecord | null,
   gate: GateRecord | null,
-) => {
-  if (did === owner) return false
-  if (!gate?.allow) return false
+): ParsedThreadGate => {
+  if (replierDid === ownerDid) {
+    return { canReply: true }
+  }
+  // if gate.allow is unset then *any* reply is allowed, if it is an empty array then *no* reply is allowed
+  if (!gate || !gate.allow) {
+    return { canReply: true }
+  }
 
-  const allowMentions = gate.allow.find(isMentionRule)
-  const allowFollowing = gate.allow.find(isFollowingRule)
+  const allowMentions = !!gate.allow.find(isMentionRule)
+  const allowFollowing = !!gate.allow.find(isFollowingRule)
   const allowListUris = gate.allow?.filter(isListRule).map((item) => item.list)
 
   // check mentions first since it's quick and synchronous
   if (allowMentions) {
-    const isMentioned = root?.facets?.some((facet) => {
-      return facet.features.some((item) => isMention(item) && item.did === did)
+    const isMentioned = rootPost?.facets?.some((facet) => {
+      return facet.features.some(
+        (item) => isMention(item) && item.did === replierDid,
+      )
     })
     if (isMentioned) {
-      return false
+      return { canReply: true, allowMentions, allowFollowing, allowListUris }
     }
   }
+  return { allowMentions, allowFollowing, allowListUris }
+}
 
-  // check follows and list containment
-  if (!allowFollowing && !allowListUris.length) {
+export const violatesThreadGate = async (
+  db: DatabaseSchema,
+  replierDid: string,
+  ownerDid: string,
+  rootPost: PostRecord | null,
+  gate: GateRecord | null,
+) => {
+  const {
+    canReply,
+    allowFollowing,
+    allowListUris = [],
+  } = parseThreadGate(replierDid, ownerDid, rootPost, gate)
+  if (canReply) {
+    return false
+  }
+  if (!allowFollowing && !allowListUris?.length) {
     return true
   }
   const { ref } = db.dynamic
   const nullResult = sql<null>`${null}`
   const check = await db
-    .selectFrom(valuesList([did]).as(sql`subject (did)`))
+    .selectFrom(valuesList([replierDid]).as(sql`subject (did)`))
     .select([
       allowFollowing
         ? db
             .selectFrom('follow')
-            .where('creator', '=', owner)
+            .where('creator', '=', ownerDid)
             .whereRef('subjectDid', '=', ref('subject.did'))
             .select('creator')
             .as('isFollowed')
@@ -91,8 +120,7 @@ export const violatesThreadGate = async (
 
   if (allowFollowing && check?.isFollowed) {
     return false
-  }
-  if (allowListUris.length && check?.isInList) {
+  } else if (allowListUris.length && check?.isInList) {
     return false
   }
 

package/src/services/feed/views.ts

@@ -1,11 +1,11 @@
 import { mapDefined } from '@atproto/common'
+import { AtUri } from '@atproto/syntax'
 import { Database } from '../../db'
 import {
   FeedViewPost,
   GeneratorView,
   PostView,
 } from '../../lexicon/types/app/bsky/feed/defs'
-import { isListRule } from '../../lexicon/types/app/bsky/feed/threadgate'
 import {
   Main as EmbedImages,
   isMain as isEmbedImages,
@@ -22,6 +22,8 @@ import {
   ViewNotFound,
   ViewRecord,
 } from '../../lexicon/types/app/bsky/embed/record'
+import { Record as PostRecord } from '../../lexicon/types/app/bsky/feed/post'
+import { isListRule } from '../../lexicon/types/app/bsky/feed/threadgate'
 import {
   PostEmbedViews,
   FeedGenInfo,
@@ -36,31 +38,45 @@ import {
 } from './types'
 import { Labels, getSelfLabels } from '../label'
 import { ImageUriBuilder } from '../../image/uri'
-import { LabelCache } from '../../label-cache'
 import { ActorInfoMap, ActorService } from '../actor'
 import { ListInfoMap, GraphService } from '../graph'
+import { FromDb } from '../types'
+import { parseThreadGate } from './util'
 
 export class FeedViews {
+  services: {
+    actor: ActorService
+    graph: GraphService
+  }
+
   constructor(
     public db: Database,
     public imgUriBuilder: ImageUriBuilder,
-    public labelCache: LabelCache,
-  ) {}
-
-  static creator(imgUriBuilder: ImageUriBuilder, labelCache: LabelCache) {
-    return (db: Database) => new FeedViews(db, imgUriBuilder, labelCache)
+    private actor: FromDb<ActorService>,
+    private graph: FromDb<GraphService>,
+  ) {
+    this.services = {
+      actor: actor(this.db),
+      graph: graph(this.db),
+    }
   }
 
-  services = {
-    actor: ActorService.creator(this.imgUriBuilder, this.labelCache)(this.db),
-    graph: GraphService.creator(this.imgUriBuilder)(this.db),
+  static creator(
+    imgUriBuilder: ImageUriBuilder,
+    actor: FromDb<ActorService>,
+    graph: FromDb<GraphService>,
+  ) {
+    return (db: Database) => new FeedViews(db, imgUriBuilder, actor, graph)
   }
 
   formatFeedGeneratorView(
     info: FeedGenInfo,
     profiles: ActorInfoMap,
-  ): GeneratorView {
+  ): GeneratorView | undefined {
     const profile = profiles[info.creator]
+    if (!profile) {
+      return undefined
+    }
     return {
       uri: info.uri,
       cid: info.cid,
@@ -91,8 +107,8 @@ export class FeedViews {
   formatFeed(
     items: FeedRow[],
     state: FeedHydrationState,
+    viewer: string | null,
     opts?: {
-      viewer?: string | null
       usePostViewUnion?: boolean
     },
   ): FeedViewPost[] {
@@ -101,7 +117,7 @@ export class FeedViews {
     const actors = this.services.actor.views.profileBasicPresentation(
       Object.keys(profiles),
       state,
-      opts,
+      viewer,
     )
     const feed: FeedViewPost[] = []
     for (const item of items) {
@@ -114,6 +130,7 @@ export class FeedViews {
         embeds,
         labels,
         lists,
+        viewer,
       )
       // skip over not found & blocked posts
       if (!post || blocks[post.uri]?.reply) {
@@ -149,6 +166,7 @@ export class FeedViews {
           labels,
           lists,
           blocks,
+          viewer,
           opts,
         )
         const replyRoot = this.formatMaybePostView(
@@ -160,6 +178,7 @@ export class FeedViews {
           labels,
           lists,
           blocks,
+          viewer,
           opts,
         )
         if (replyRoot && replyParent) {
@@ -182,6 +201,7 @@ export class FeedViews {
     embeds: PostEmbedViews,
     labels: Labels,
     lists: ListInfoMap,
+    viewer: string | null,
   ): PostView | undefined {
     const post = posts[uri]
     const gate = threadgates[uri]
@@ -207,6 +227,14 @@ export class FeedViews {
         ? {
             repost: post.requesterRepost ?? undefined,
             like: post.requesterLike ?? undefined,
+            replyDisabled: this.userReplyDisabled(
+              uri,
+              actors,
+              posts,
+              threadgates,
+              lists,
+              viewer,
+            ),
           }
         : undefined,
       labels: [...postLabels, ...postSelfLabels],
@@ -217,6 +245,50 @@ export class FeedViews {
     }
   }
 
+  userReplyDisabled(
+    uri: string,
+    actors: ActorInfoMap,
+    posts: PostInfoMap,
+    threadgates: ThreadgateInfoMap,
+    lists: ListInfoMap,
+    viewer: string | null,
+  ): boolean | undefined {
+    if (viewer === null) {
+      return undefined
+    } else if (posts[uri]?.violatesThreadGate) {
+      return true
+    }
+
+    const rootUriStr: string =
+      posts[uri]?.record?.['reply']?.['root']?.['uri'] ?? uri
+    const gate = threadgates[rootUriStr]?.record
+    if (!gate) {
+      return undefined
+    }
+    const rootPost = posts[rootUriStr]?.record as PostRecord | undefined
+    const ownerDid = new AtUri(rootUriStr).hostname
+
+    const {
+      canReply,
+      allowFollowing,
+      allowListUris = [],
+    } = parseThreadGate(viewer, ownerDid, rootPost ?? null, gate ?? null)
+
+    if (canReply) {
+      return false
+    }
+    if (allowFollowing && actors[ownerDid]?.viewer?.followedBy) {
+      return false
+    }
+    for (const listUri of allowListUris) {
+      const list = lists[listUri]
+      if (list?.viewerInList) {
+        return false
+      }
+    }
+    return true
+  }
+
   formatMaybePostView(
     uri: string,
     actors: ActorInfoMap,
@@ -226,6 +298,7 @@ export class FeedViews {
     labels: Labels,
     lists: ListInfoMap,
     blocks: PostBlocksMap,
+    viewer: string | null,
     opts?: {
       usePostViewUnion?: boolean
     },
@@ -238,6 +311,7 @@ export class FeedViews {
       embeds,
       labels,
       lists,
+      viewer,
     )
     if (!post) {
       if (!opts?.usePostViewUnion) return

package/src/services/graph/index.ts

@@ -4,6 +4,10 @@ import { ImageUriBuilder } from '../../image/uri'
 import { valuesList } from '../../db/util'
 import { ListInfo } from './types'
 import { ActorInfoMap } from '../actor'
+import {
+  ListView,
+  ListViewBasic,
+} from '../../lexicon/types/app/bsky/graph/defs'
 
 export * from './types'
 
@@ -91,6 +95,12 @@ export class GraphService {
           .whereRef('list_block.subjectUri', '=', ref('list.uri'))
           .select('list_block.uri')
           .as('viewerListBlockUri'),
+        this.db.db
+          .selectFrom('list_item')
+          .whereRef('list_item.listUri', '=', ref('list.uri'))
+          .where('list_item.subjectDid', '=', viewer ?? '')
+          .select('list_item.uri')
+          .as('viewerInList'),
       ])
   }
 
@@ -99,7 +109,11 @@ export class GraphService {
       .selectFrom('list_item')
       .innerJoin('actor as subject', 'subject.did', 'list_item.subjectDid')
       .selectAll('subject')
-      .select(['list_item.cid as cid', 'list_item.sortAt as sortAt'])
+      .select([
+        'list_item.uri as uri',
+        'list_item.cid as cid',
+        'list_item.sortAt as sortAt',
+      ])
   }
 
   async getBlockAndMuteState(
@@ -229,7 +243,10 @@ export class GraphService {
     )
   }
 
-  formatListView(list: ListInfo, profiles: ActorInfoMap) {
+  formatListView(list: ListInfo, profiles: ActorInfoMap): ListView | undefined {
+    if (!profiles[list.creator]) {
+      return undefined
+    }
     return {
       ...this.formatListViewBasic(list),
       creator: profiles[list.creator],
@@ -237,10 +254,11 @@ export class GraphService {
       descriptionFacets: list.descriptionFacets
         ? JSON.parse(list.descriptionFacets)
         : undefined,
+      indexedAt: list.sortAt,
     }
   }
 
-  formatListViewBasic(list: ListInfo) {
+  formatListViewBasic(list: ListInfo): ListViewBasic {
     return {
       uri: list.uri,
       cid: list.cid,

package/src/services/graph/types.ts

@@ -4,6 +4,7 @@ import { List } from '../../db/tables/list'
 export type ListInfo = Selectable<List> & {
   viewerMuted: string | null
   viewerListBlockUri: string | null
+  viewerInList: string | null
 }
 
 export type ListInfoMap = Record<string, ListInfo>