@atproto/bsky 0.0.60 → 0.0.62

package/src/data-plane/server/db/tables/thread-mute.ts

@@ -0,0 +1,9 @@
+export const tableName = 'thread_mute'
+
+export interface ThreadMute {
+  rootUri: string
+  mutedByDid: string
+  createdAt: string
+}
+
+export type PartialDB = { [tableName]: ThreadMute }

package/src/data-plane/server/indexing/processor.ts

@@ -247,7 +247,8 @@ export class RecordProcessor<T, S> {
     }
     for (const chunk of chunkArray(notifs, 500)) {
       runOnCommit.push(async (db) => {
-        await db.db.insertInto('notification').values(chunk).execute()
+        const filtered = await this.filterNotifsForThreadMutes(chunk)
+        await db.db.insertInto('notification').values(filtered).execute()
       })
     }
     // Need to ensure notif deletion always happens before creation, otherwise delete may clobber in a race.
@@ -256,6 +257,33 @@ export class RecordProcessor<T, S> {
     }
   }
 
+  async filterNotifsForThreadMutes(notifs: Notif[]): Promise<Notif[]> {
+    const isBlocked = await Promise.all(
+      notifs.map((n) => this.isNotifBlockedByThreadMute(n)),
+    )
+    return notifs.filter((_, i) => !isBlocked[i])
+  }
+
+  async isNotifBlockedByThreadMute(notif: Notif): Promise<boolean> {
+    const subject = notif.reasonSubject
+    if (!subject) return false
+    if (subject.startsWith('did:')) return false
+    const post = await this.db
+      .selectFrom('post')
+      .select(['uri', 'replyRoot'])
+      .where('uri', '=', subject)
+      .executeTakeFirst()
+    if (!post) return false
+    const threadRoot = post.replyRoot ?? post.uri
+    const threadMute = await this.db
+      .selectFrom('thread_mute')
+      .selectAll()
+      .where('mutedByDid', '=', notif.did)
+      .where('rootUri', '=', threadRoot)
+      .executeTakeFirst()
+    return !!threadMute
+  }
+
   aggregateOnCommit(indexed: S) {
     const { updateAggregates } = this.params
     if (!updateAggregates) return

package/src/data-plane/server/routes/follows.ts

@@ -1,6 +1,7 @@
 import { keyBy } from '@atproto/common'
 import { ServiceImpl } from '@connectrpc/connect'
 import { Service } from '../../../proto/bsky_connect'
+import { FollowsFollowing } from '../../../proto/bsky_pb'
 import { Database } from '../db'
 import { TimeCidKeyset, paginate } from '../db/pagination'
 
@@ -92,7 +93,49 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       cursor: keyset.packFromResult(follows),
     }
   },
-  async getFollowsFollowing() {
-    throw new Error('not implemented')
+
+  /**
+   * Return known followers of a given actor.
+   *
+   * Example:
+   *   - Alice follows Bob
+   *   - Bob follows Dan
+   *
+   *   If Alice (the viewer) looks at Dan's profile (the subject), she should see that Bob follows Dan
+   */
+  async getFollowsFollowing(req) {
+    const { actorDid: viewerDid, targetDids: subjectDids } = req
+
+    /*
+     * 1. Get all the people the Alice is following
+     * 2. Get all the people the Dan is followed by
+     * 3. Find the intersection
+     */
+
+    const results: FollowsFollowing[] = []
+
+    for (const subjectDid of subjectDids) {
+      const followsReq = db.db
+        .selectFrom('follow')
+        .where('follow.creator', '=', viewerDid)
+        .where(
+          'follow.subjectDid',
+          'in',
+          db.db
+            .selectFrom('follow')
+            .where('follow.subjectDid', '=', subjectDid)
+            .select(['creator']),
+        )
+        .select(['subjectDid'])
+      const rows = await followsReq.execute()
+      results.push(
+        new FollowsFollowing({
+          targetDid: subjectDid,
+          dids: rows.map((r) => r.subjectDid),
+        }),
+      )
+    }
+
+    return { results }
   },
 })

package/src/data-plane/server/routes/mutes.ts

@@ -5,6 +5,7 @@ import { ids } from '../../../lexicon/lexicons'
 import { Service } from '../../../proto/bsky_connect'
 import { Database } from '../db'
 import { CreatedAtDidKeyset, TimeCidKeyset, paginate } from '../db/pagination'
+import { keyBy } from '@atproto/common'
 
 export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   async getActorMutesActor(req) {
@@ -166,6 +167,22 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       .where('mutedByDid', '=', actorDid)
       .execute()
   },
+
+  async getThreadMutesOnSubjects(req) {
+    const { actorDid, threadRoots } = req
+    if (threadRoots.length === 0) {
+      return { muted: [] }
+    }
+    const res = await db.db
+      .selectFrom('thread_mute')
+      .selectAll()
+      .where('mutedByDid', '=', actorDid)
+      .where('rootUri', 'in', threadRoots)
+      .execute()
+    const byRootUri = keyBy(res, 'rootUri')
+    const muted = threadRoots.map((uri) => !!byRootUri[uri])
+    return { muted }
+  },
 })
 
 const isListUri = (uri: string) =>

package/src/hydration/actor.ts

@@ -38,10 +38,16 @@ export type ProfileViewerState = {
   blockingByList?: string
   following?: string
   followedBy?: string
+  knownFollowers?: {
+    count: number
+    followers: string[]
+  }
 }
 
 export type ProfileViewerStates = HydrationMap<ProfileViewerState>
 
+export type KnownFollowers = HydrationMap<ProfileViewerState['knownFollowers']>
+
 export type ProfileAgg = {
   followers: number
   follows: number
@@ -171,6 +177,30 @@ export class ActorHydrator {
     }, new HydrationMap<ProfileViewerState>())
   }
 
+  async getKnownFollowers(
+    dids: string[],
+    viewer: string | null,
+  ): Promise<KnownFollowers> {
+    if (!viewer) return new HydrationMap<ProfileViewerState['knownFollowers']>()
+    const { results: knownFollowersResults } =
+      await this.dataplane.getFollowsFollowing({
+        actorDid: viewer,
+        targetDids: dids,
+      })
+    return dids.reduce((acc, did, i) => {
+      const result = knownFollowersResults[i]?.dids
+      return acc.set(
+        did,
+        result && result.length > 0
+          ? {
+              count: result.length,
+              followers: result.slice(0, 5),
+            }
+          : undefined,
+      )
+    }, new HydrationMap<ProfileViewerState['knownFollowers']>())
+  }
+
   async getProfileAggregates(dids: string[]): Promise<ProfileAggs> {
     if (!dids.length) return new HydrationMap<ProfileAgg>()
     const counts = await this.dataplane.getCountsForUsers({ dids })

package/src/hydration/feed.ts

@@ -13,6 +13,7 @@ import {
 } from './util'
 import { AtUri } from '@atproto/syntax'
 import { ids } from '../lexicon/lexicons'
+import { dedupeStrs } from '@atproto/common'
 
 export type Post = RecordInfo<PostRecord> & { violatesThreadGate: boolean }
 export type Posts = HydrationMap<Post>
@@ -20,6 +21,7 @@ export type Posts = HydrationMap<Post>
 export type PostViewerState = {
   like?: string
   repost?: string
+  threadMuted?: boolean
 }
 
 export type PostViewerStates = HydrationMap<PostViewerState>
@@ -57,6 +59,7 @@ export type Threadgate = RecordInfo<ThreadgateRecord>
 export type Threadgates = HydrationMap<Threadgate>
 
 export type ItemRef = { uri: string; cid?: string }
+export type ThreadRef = ItemRef & { threadRoot: string }
 
 // @NOTE the feed item types in the protos for author feeds and timelines
 // technically have additional fields, not supported by the mock dataplane.
@@ -85,11 +88,12 @@ export class FeedHydrator {
   }
 
   async getPostViewerStates(
-    refs: ItemRef[],
+    refs: ThreadRef[],
     viewer: string,
   ): Promise<PostViewerStates> {
     if (!refs.length) return new HydrationMap<PostViewerState>()
-    const [likes, reposts] = await Promise.all([
+    const threadRoots = refs.map((r) => r.threadRoot)
+    const [likes, reposts, threadMutesMap] = await Promise.all([
       this.dataplane.getLikesByActorAndSubjects({
         actorDid: viewer,
         refs,
@@ -98,15 +102,31 @@ export class FeedHydrator {
         actorDid: viewer,
         refs,
       }),
+      this.getThreadMutes(threadRoots, viewer),
     ])
-    return refs.reduce((acc, { uri }, i) => {
+    return refs.reduce((acc, { uri, threadRoot }, i) => {
       return acc.set(uri, {
         like: parseString(likes.uris[i]),
         repost: parseString(reposts.uris[i]),
+        threadMuted: threadMutesMap.get(threadRoot) ?? false,
       })
     }, new HydrationMap<PostViewerState>())
   }
 
+  private async getThreadMutes(
+    threadRoots: string[],
+    viewer: string,
+  ): Promise<Map<string, boolean>> {
+    const deduped = dedupeStrs(threadRoots)
+    const threadMutes = await this.dataplane.getThreadMutesOnSubjects({
+      actorDid: viewer,
+      threadRoots: deduped,
+    })
+    return deduped.reduce((acc, cur, i) => {
+      return acc.set(cur, threadMutes.muted[i] ?? false)
+    }, new Map<string, boolean>())
+  }
+
   async getPostAggregates(refs: ItemRef[]): Promise<PostAggs> {
     if (!refs.length) return new HydrationMap<PostAgg>()
     const counts = await this.dataplane.getInteractionCounts({ refs })

package/src/hydration/hydrator.ts

@@ -7,12 +7,14 @@ import { ids } from '../lexicon/lexicons'
 import { isMain as isEmbedRecord } from '../lexicon/types/app/bsky/embed/record'
 import { isMain as isEmbedRecordWithMedia } from '../lexicon/types/app/bsky/embed/recordWithMedia'
 import { isListRule } from '../lexicon/types/app/bsky/feed/threadgate'
+import { hydrationLogger } from '../logger'
 import {
   ActorHydrator,
   ProfileAggs,
   Actors,
   ProfileViewerStates,
   ProfileViewerState,
+  KnownFollowers,
 } from './actor'
 import {
   Follows,
@@ -93,6 +95,7 @@ export type HydrationState = {
   labelers?: Labelers
   labelerViewers?: LabelerViewerStates
   labelerAggs?: LabelerAggs
+  knownFollowers?: KnownFollowers
 }
 
 export type PostBlock = { embed: boolean; reply: boolean }
@@ -143,6 +146,7 @@ export class Hydrator {
     profileViewers?.forEach((item) => {
       removeNonModListsFromProfileViewer(item, listState)
     })
+
     return mergeStates(listState, {
       profileViewers,
       ctx,
@@ -190,13 +194,29 @@ export class Hydrator {
     dids: string[],
     ctx: HydrateCtx,
   ): Promise<HydrationState> {
+    let knownFollowers: KnownFollowers = new HydrationMap()
+
+    try {
+      knownFollowers = await this.actor.getKnownFollowers(dids, ctx.viewer)
+    } catch (err) {
+      hydrationLogger.error(
+        { err },
+        'Failed to get known followers for profiles',
+      )
+    }
+
+    const knownFollowersDids = Array.from(knownFollowers.values())
+      .filter(Boolean)
+      .flatMap((f) => f!.followers)
+    const allDids = Array.from(new Set(dids.concat(knownFollowersDids)))
     const [state, profileAggs] = await Promise.all([
-      this.hydrateProfiles(dids, ctx),
+      this.hydrateProfiles(allDids, ctx),
       this.actor.getProfileAggregates(dids),
     ])
     return {
       ...state,
       profileAggs,
+      knownFollowers,
     }
   }
 
@@ -314,6 +334,16 @@ export class Hydrator {
     const posts =
       mergeManyMaps(postsLayer0, postsLayer1, postsLayer2) ?? postsLayer0
     const allPostUris = [...posts.keys()]
+    const allRefs = [
+      ...refs,
+      ...postUrisLayer1.map(uriToRef), // supports aggregates on embed #viewRecords
+      ...postUrisLayer2.map(uriToRef),
+    ]
+    const threadRefs = allRefs.map((ref) => ({
+      ...ref,
+      threadRoot: posts.get(ref.uri)?.record.reply?.root.uri ?? ref.uri,
+    }))
+
     const [
       postAggs,
       postViewers,
@@ -324,12 +354,10 @@ export class Hydrator {
       feedGenState,
       labelerState,
     ] = await Promise.all([
-      this.feed.getPostAggregates([
-        ...refs,
-        ...postUrisLayer1.map(uriToRef), // supports aggregates on embed #viewRecords
-        ...postUrisLayer2.map(uriToRef),
-      ]),
-      ctx.viewer ? this.feed.getPostViewerStates(refs, ctx.viewer) : undefined,
+      this.feed.getPostAggregates(allRefs),
+      ctx.viewer
+        ? this.feed.getPostViewerStates(threadRefs, ctx.viewer)
+        : undefined,
       this.label.getLabelsForSubjects(allPostUris, ctx.labelers),
       this.hydratePostBlocks(posts),
       this.hydrateProfiles(allPostUris.map(didFromUri), ctx),
@@ -856,6 +884,7 @@ export const mergeStates = (
     labelers: mergeMaps(stateA.labelers, stateB.labelers),
     labelerAggs: mergeMaps(stateA.labelerAggs, stateB.labelerAggs),
     labelerViewers: mergeMaps(stateA.labelerViewers, stateB.labelerViewers),
+    knownFollowers: mergeMaps(stateA.knownFollowers, stateB.knownFollowers),
   }
 }
 

package/src/lexicon/index.ts

@@ -110,6 +110,7 @@ import * as AppBskyFeedSendInteractions from './types/app/bsky/feed/sendInteract
 import * as AppBskyGraphGetBlocks from './types/app/bsky/graph/getBlocks'
 import * as AppBskyGraphGetFollowers from './types/app/bsky/graph/getFollowers'
 import * as AppBskyGraphGetFollows from './types/app/bsky/graph/getFollows'
+import * as AppBskyGraphGetKnownFollowers from './types/app/bsky/graph/getKnownFollowers'
 import * as AppBskyGraphGetList from './types/app/bsky/graph/getList'
 import * as AppBskyGraphGetListBlocks from './types/app/bsky/graph/getListBlocks'
 import * as AppBskyGraphGetListMutes from './types/app/bsky/graph/getListMutes'
@@ -119,8 +120,10 @@ import * as AppBskyGraphGetRelationships from './types/app/bsky/graph/getRelatio
 import * as AppBskyGraphGetSuggestedFollowsByActor from './types/app/bsky/graph/getSuggestedFollowsByActor'
 import * as AppBskyGraphMuteActor from './types/app/bsky/graph/muteActor'
 import * as AppBskyGraphMuteActorList from './types/app/bsky/graph/muteActorList'
+import * as AppBskyGraphMuteThread from './types/app/bsky/graph/muteThread'
 import * as AppBskyGraphUnmuteActor from './types/app/bsky/graph/unmuteActor'
 import * as AppBskyGraphUnmuteActorList from './types/app/bsky/graph/unmuteActorList'
+import * as AppBskyGraphUnmuteThread from './types/app/bsky/graph/unmuteThread'
 import * as AppBskyLabelerGetServices from './types/app/bsky/labeler/getServices'
 import * as AppBskyNotificationGetUnreadCount from './types/app/bsky/notification/getUnreadCount'
 import * as AppBskyNotificationListNotifications from './types/app/bsky/notification/listNotifications'
@@ -1473,6 +1476,17 @@ export class AppBskyGraphNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  getKnownFollowers<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyGraphGetKnownFollowers.Handler<ExtractAuth<AV>>,
+      AppBskyGraphGetKnownFollowers.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.graph.getKnownFollowers' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getList<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -1572,6 +1586,17 @@ export class AppBskyGraphNS {
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  muteThread<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyGraphMuteThread.Handler<ExtractAuth<AV>>,
+      AppBskyGraphMuteThread.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.graph.muteThread' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   unmuteActor<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
@@ -1593,6 +1618,17 @@ export class AppBskyGraphNS {
     const nsid = 'app.bsky.graph.unmuteActorList' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
+
+  unmuteThread<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppBskyGraphUnmuteThread.Handler<ExtractAuth<AV>>,
+      AppBskyGraphUnmuteThread.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'app.bsky.graph.unmuteThread' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
 }
 
 export class AppBskyLabelerNS {

package/src/lexicon/lexicons.ts

@@ -4107,6 +4107,29 @@ export const schemaDict = {
             type: 'string',
             format: 'at-uri',
           },
+          knownFollowers: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#knownFollowers',
+          },
+        },
+      },
+      knownFollowers: {
+        type: 'object',
+        description: "The subject's followers whom you also follow",
+        required: ['count', 'followers'],
+        properties: {
+          count: {
+            type: 'integer',
+          },
+          followers: {
+            type: 'array',
+            minLength: 0,
+            maxLength: 5,
+            items: {
+              type: 'ref',
+              ref: 'lex:app.bsky.actor.defs#profileViewBasic',
+            },
+          },
         },
       },
       preferences: {
@@ -5079,6 +5102,9 @@ export const schemaDict = {
             type: 'string',
             format: 'at-uri',
           },
+          threadMuted: {
+            type: 'boolean',
+          },
           replyDisabled: {
             type: 'boolean',
           },
@@ -7101,6 +7127,59 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyGraphGetKnownFollowers: {
+    lexicon: 1,
+    id: 'app.bsky.graph.getKnownFollowers',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Enumerates accounts which follow a specified account (actor) and are followed by the viewer.',
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['subject', 'followers'],
+            properties: {
+              subject: {
+                type: 'ref',
+                ref: 'lex:app.bsky.actor.defs#profileView',
+              },
+              cursor: {
+                type: 'string',
+              },
+              followers: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:app.bsky.actor.defs#profileView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   AppBskyGraphGetList: {
     lexicon: 1,
     id: 'app.bsky.graph.getList',
@@ -7599,6 +7678,30 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyGraphMuteThread: {
+    lexicon: 1,
+    id: 'app.bsky.graph.muteThread',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Mutes a thread preventing notifications from the thread and any of its children. Mutes are private in Bluesky. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['root'],
+            properties: {
+              root: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   AppBskyGraphUnmuteActor: {
     lexicon: 1,
     id: 'app.bsky.graph.unmuteActor',
@@ -7645,6 +7748,29 @@ export const schemaDict = {
       },
     },
   },
+  AppBskyGraphUnmuteThread: {
+    lexicon: 1,
+    id: 'app.bsky.graph.unmuteThread',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Unmutes the specified thread. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['root'],
+            properties: {
+              root: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   AppBskyLabelerDefs: {
     lexicon: 1,
     id: 'app.bsky.labeler.defs',
@@ -9523,6 +9649,7 @@ export const ids = {
   AppBskyGraphGetBlocks: 'app.bsky.graph.getBlocks',
   AppBskyGraphGetFollowers: 'app.bsky.graph.getFollowers',
   AppBskyGraphGetFollows: 'app.bsky.graph.getFollows',
+  AppBskyGraphGetKnownFollowers: 'app.bsky.graph.getKnownFollowers',
   AppBskyGraphGetList: 'app.bsky.graph.getList',
   AppBskyGraphGetListBlocks: 'app.bsky.graph.getListBlocks',
   AppBskyGraphGetListMutes: 'app.bsky.graph.getListMutes',
@@ -9536,8 +9663,10 @@ export const ids = {
   AppBskyGraphListitem: 'app.bsky.graph.listitem',
   AppBskyGraphMuteActor: 'app.bsky.graph.muteActor',
   AppBskyGraphMuteActorList: 'app.bsky.graph.muteActorList',
+  AppBskyGraphMuteThread: 'app.bsky.graph.muteThread',
   AppBskyGraphUnmuteActor: 'app.bsky.graph.unmuteActor',
   AppBskyGraphUnmuteActorList: 'app.bsky.graph.unmuteActorList',
+  AppBskyGraphUnmuteThread: 'app.bsky.graph.unmuteThread',
   AppBskyLabelerDefs: 'app.bsky.labeler.defs',
   AppBskyLabelerGetServices: 'app.bsky.labeler.getServices',
   AppBskyLabelerService: 'app.bsky.labeler.service',

package/src/lexicon/types/app/bsky/actor/defs.ts

@@ -133,6 +133,7 @@ export interface ViewerState {
   blockingByList?: AppBskyGraphDefs.ListViewBasic
   following?: string
   followedBy?: string
+  knownFollowers?: KnownFollowers
   [k: string]: unknown
 }
 
@@ -148,6 +149,25 @@ export function validateViewerState(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#viewerState', v)
 }
 
+/** The subject's followers whom you also follow */
+export interface KnownFollowers {
+  count: number
+  followers: ProfileViewBasic[]
+  [k: string]: unknown
+}
+
+export function isKnownFollowers(v: unknown): v is KnownFollowers {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#knownFollowers'
+  )
+}
+
+export function validateKnownFollowers(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#knownFollowers', v)
+}
+
 export type Preferences = (
   | AdultContentPref
   | ContentLabelPref

package/src/lexicon/types/app/bsky/feed/defs.ts

@@ -49,6 +49,7 @@ export function validatePostView(v: unknown): ValidationResult {
 export interface ViewerState {
   repost?: string
   like?: string
+  threadMuted?: boolean
   replyDisabled?: boolean
   [k: string]: unknown
 }