@atproto/bsky 0.0.65 → 0.0.67

package/src/lexicon/lexicons.ts

@@ -3343,7 +3343,7 @@ export const schemaDict = {
       main: {
         type: 'query',
         description:
-          'List blob CIDso for an account, since some repo revision. Does not require auth; implemented by PDS.',
+          'List blob CIDs for an account, since some repo revision. Does not require auth; implemented by PDS.',
         parameters: {
           type: 'params',
           required: ['did'],
@@ -4166,6 +4166,8 @@ export const schemaDict = {
             'lex:app.bsky.actor.defs#interestsPref',
             'lex:app.bsky.actor.defs#mutedWordsPref',
             'lex:app.bsky.actor.defs#hiddenPostsPref',
+            'lex:app.bsky.actor.defs#bskyAppStatePref',
+            'lex:app.bsky.actor.defs#labelersPref',
           ],
         },
       },
@@ -4407,6 +4409,39 @@ export const schemaDict = {
           },
         },
       },
+      bskyAppStatePref: {
+        description:
+          "A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this.",
+        type: 'object',
+        properties: {
+          activeProgressGuide: {
+            type: 'ref',
+            ref: 'lex:app.bsky.actor.defs#bskyAppProgressGuide',
+          },
+          queuedNudges: {
+            description:
+              'An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user.',
+            type: 'array',
+            maxLength: 1000,
+            items: {
+              type: 'string',
+              maxLength: 100,
+            },
+          },
+        },
+      },
+      bskyAppProgressGuide: {
+        description:
+          'If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress.',
+        type: 'object',
+        required: ['guide'],
+        properties: {
+          guide: {
+            type: 'string',
+            maxLength: 100,
+          },
+        },
+      },
     },
   },
   AppBskyActorGetPreferences: {
@@ -4923,6 +4958,7 @@ export const schemaDict = {
               'lex:app.bsky.feed.defs#generatorView',
               'lex:app.bsky.graph.defs#listView',
               'lex:app.bsky.labeler.defs#labelerView',
+              'lex:app.bsky.graph.defs#starterPackViewBasic',
             ],
           },
         },
@@ -8676,6 +8712,12 @@ export const schemaDict = {
             cursor: {
               type: 'string',
             },
+            relativeToDid: {
+              type: 'string',
+              format: 'did',
+              description:
+                'DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer.',
+            },
           },
         },
         output: {

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

@@ -184,6 +184,8 @@ export type Preferences = (
   | InterestsPref
   | MutedWordsPref
   | HiddenPostsPref
+  | BskyAppStatePref
+  | LabelersPref
   | { $type: string; [k: string]: unknown }
 )[]
 
@@ -456,3 +458,41 @@ export function isLabelerPrefItem(v: unknown): v is LabelerPrefItem {
 export function validateLabelerPrefItem(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#labelerPrefItem', v)
 }
+
+/** A grab bag of state that's specific to the bsky.app program. Third-party apps shouldn't use this. */
+export interface BskyAppStatePref {
+  activeProgressGuide?: BskyAppProgressGuide
+  /** An array of tokens which identify nudges (modals, popups, tours, highlight dots) that should be shown to the user. */
+  queuedNudges?: string[]
+  [k: string]: unknown
+}
+
+export function isBskyAppStatePref(v: unknown): v is BskyAppStatePref {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#bskyAppStatePref'
+  )
+}
+
+export function validateBskyAppStatePref(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#bskyAppStatePref', v)
+}
+
+/** If set, an active progress guide. Once completed, can be set to undefined. Should have unspecced fields tracking progress. */
+export interface BskyAppProgressGuide {
+  guide: string
+  [k: string]: unknown
+}
+
+export function isBskyAppProgressGuide(v: unknown): v is BskyAppProgressGuide {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#bskyAppProgressGuide'
+  )
+}
+
+export function validateBskyAppProgressGuide(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#bskyAppProgressGuide', v)
+}

package/src/lexicon/types/app/bsky/embed/record.ts

@@ -41,6 +41,7 @@ export interface View {
     | AppBskyFeedDefs.GeneratorView
     | AppBskyGraphDefs.ListView
     | AppBskyLabelerDefs.LabelerView
+    | AppBskyGraphDefs.StarterPackViewBasic
     | { $type: string; [k: string]: unknown }
   [k: string]: unknown
 }

package/src/lexicon/types/app/bsky/unspecced/getSuggestionsSkeleton.ts

@@ -14,6 +14,8 @@ export interface QueryParams {
   viewer?: string
   limit: number
   cursor?: string
+  /** DID of the account to get suggestions relative to. If not provided, suggestions will be based on the viewer. */
+  relativeToDid?: string
 }
 
 export type InputSchema = undefined

package/src/logger.ts

@@ -12,6 +12,8 @@ export const labelerLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:labeler')
 export const hydrationLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky:hydration')
+export const featureGatesLogger: ReturnType<typeof subsystemLogger> =
+  subsystemLogger('bsky:featuregates')
 export const httpLogger: ReturnType<typeof subsystemLogger> =
   subsystemLogger('bsky')
 

package/src/views/index.ts

@@ -2,7 +2,6 @@ import { AtUri, INVALID_HANDLE, normalizeDatetimeAlways } from '@atproto/syntax'
 import { mapDefined } from '@atproto/common'
 import { ImageUriBuilder } from '../image/uri'
 import { HydrationState } from '../hydration/hydrator'
-import { ProfileViewerState as HydratorProfileViewerState } from '../hydration/actor'
 import { ids } from '../lexicon/lexicons'
 import {
   ProfileViewDetailed,
@@ -113,10 +112,7 @@ export class Views {
     if (!actor) return
     const baseView = this.profile(did, state)
     if (!baseView) return
-    const knownFollowersSkeleton = state.knownFollowers?.get(did)
-    const knownFollowers = knownFollowersSkeleton
-      ? this.knownFollowers(knownFollowersSkeleton, state)
-      : undefined
+    const knownFollowers = this.knownFollowers(did, state)
     const profileAggs = state.profileAggs?.get(did)
     return {
       ...baseView,
@@ -213,6 +209,26 @@ export class Views {
     }
   }
 
+  profileKnownFollowers(
+    did: string,
+    state: HydrationState,
+  ): ProfileView | undefined {
+    const actor = state.actors?.get(did)
+    if (!actor) return
+    const baseView = this.profile(did, state)
+    if (!baseView) return
+    const knownFollowers = this.knownFollowers(did, state)
+    return {
+      ...baseView,
+      viewer: baseView.viewer
+        ? {
+            ...baseView.viewer,
+            knownFollowers,
+          }
+        : undefined,
+    }
+  }
+
   profileViewer(
     did: string,
     state: HydrationState,
@@ -237,15 +253,22 @@ export class Views {
     }
   }
 
-  knownFollowers(
-    knownFollowers: Required<HydratorProfileViewerState>['knownFollowers'],
-    state: HydrationState,
-  ) {
-    const followers = mapDefined(knownFollowers.followers, (did) => {
-      if (this.viewerBlockExists(did, state)) {
+  knownFollowers(did: string, state: HydrationState) {
+    const knownFollowers = state.knownFollowers?.get(did)
+    if (!knownFollowers) return
+    const blocks = state.bidirectionalBlocks?.get(did)
+    const followers = mapDefined(knownFollowers.followers, (followerDid) => {
+      if (this.viewerBlockExists(followerDid, state)) {
         return undefined
       }
-      return this.profileBasic(did, state)
+      if (blocks?.get(followerDid) === true) {
+        return undefined
+      }
+      if (this.actorIsNoHosted(followerDid, state)) {
+        // @TODO only needed right now to work around getProfile's { includeTakedowns: true }
+        return undefined
+      }
+      return this.profileBasic(followerDid, state)
     })
     return { count: knownFollowers.count, followers }
   }
@@ -936,6 +959,11 @@ export class Views {
       if (!view) return this.embedNotFound(uri)
       view.$type = 'app.bsky.labeler.defs#labelerView'
       return this.recordEmbedWrapper(view, withTypeTag)
+    } else if (parsedUri.collection === ids.AppBskyGraphStarterpack) {
+      const view = this.starterPackBasic(uri, state)
+      if (!view) return this.embedNotFound(uri)
+      view.$type = 'app.bsky.graph.defs#starterPackViewBasic'
+      return this.recordEmbedWrapper(view, withTypeTag)
     }
     return this.embedNotFound(uri)
   }

package/tests/__snapshots__/feed-generation.test.ts.snap

@@ -47,6 +47,53 @@ Object {
 }
 `;
 
+exports[`feed generation does not embed taken-down starter pack records in posts 1`] = `
+Object {
+  "author": Object {
+    "avatar": "https://bsky.public.url/img/avatar/plain/user(1)/cids(1)@jpeg",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "did": "user(0)",
+    "displayName": "bobby",
+    "handle": "bob.test",
+    "labels": Array [],
+    "viewer": Object {
+      "blockedBy": false,
+      "muted": false,
+    },
+  },
+  "cid": "cids(0)",
+  "embed": Object {
+    "$type": "app.bsky.embed.record#view",
+    "record": Object {
+      "$type": "app.bsky.embed.record#viewNotFound",
+      "notFound": true,
+      "uri": "record(1)",
+    },
+  },
+  "indexedAt": "1970-01-01T00:00:00.000Z",
+  "labels": Array [],
+  "likeCount": 0,
+  "record": Object {
+    "$type": "app.bsky.feed.post",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "embed": Object {
+      "$type": "app.bsky.embed.record",
+      "record": Object {
+        "cid": "cids(2)",
+        "uri": "record(1)",
+      },
+    },
+    "text": "annoying starter pack",
+  },
+  "replyCount": 0,
+  "repostCount": 0,
+  "uri": "record(0)",
+  "viewer": Object {
+    "threadMuted": false,
+  },
+}
+`;
+
 exports[`feed generation embeds feed generator records in posts 1`] = `
 Object {
   "author": Object {
@@ -134,6 +181,95 @@ Object {
 }
 `;
 
+exports[`feed generation embeds starter pack records in posts 1`] = `
+Object {
+  "author": Object {
+    "avatar": "https://bsky.public.url/img/avatar/plain/user(1)/cids(1)@jpeg",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "did": "user(0)",
+    "displayName": "bobby",
+    "handle": "bob.test",
+    "labels": Array [],
+    "viewer": Object {
+      "blockedBy": false,
+      "muted": false,
+    },
+  },
+  "cid": "cids(0)",
+  "embed": Object {
+    "$type": "app.bsky.embed.record#view",
+    "record": Object {
+      "$type": "app.bsky.graph.defs#starterPackViewBasic",
+      "cid": "cids(2)",
+      "creator": Object {
+        "avatar": "https://bsky.public.url/img/avatar/plain/user(3)/cids(1)@jpeg",
+        "createdAt": "1970-01-01T00:00:00.000Z",
+        "did": "user(2)",
+        "displayName": "ali",
+        "handle": "alice.test",
+        "labels": Array [
+          Object {
+            "cid": "cids(3)",
+            "cts": "1970-01-01T00:00:00.000Z",
+            "src": "user(2)",
+            "uri": "record(5)",
+            "val": "self-label-a",
+          },
+          Object {
+            "cid": "cids(3)",
+            "cts": "1970-01-01T00:00:00.000Z",
+            "src": "user(2)",
+            "uri": "record(5)",
+            "val": "self-label-b",
+          },
+        ],
+        "viewer": Object {
+          "blockedBy": false,
+          "followedBy": "record(4)",
+          "following": "record(3)",
+          "muted": false,
+        },
+      },
+      "indexedAt": "1970-01-01T00:00:00.000Z",
+      "joinedAllTimeCount": 0,
+      "joinedWeekCount": 0,
+      "labels": Array [],
+      "record": Object {
+        "$type": "app.bsky.graph.starterpack",
+        "createdAt": "1970-01-01T00:00:00.000Z",
+        "description": "",
+        "descriptionFacets": Array [],
+        "feeds": Array [],
+        "list": "record(2)",
+        "name": "awesome starter pack!",
+      },
+      "uri": "record(1)",
+    },
+  },
+  "indexedAt": "1970-01-01T00:00:00.000Z",
+  "labels": Array [],
+  "likeCount": 0,
+  "record": Object {
+    "$type": "app.bsky.feed.post",
+    "createdAt": "1970-01-01T00:00:00.000Z",
+    "embed": Object {
+      "$type": "app.bsky.embed.record",
+      "record": Object {
+        "cid": "cids(2)",
+        "uri": "record(1)",
+      },
+    },
+    "text": "sick starter pack!",
+  },
+  "replyCount": 0,
+  "repostCount": 0,
+  "uri": "record(0)",
+  "viewer": Object {
+    "threadMuted": false,
+  },
+}
+`;
+
 exports[`feed generation getActorFeeds fetches feed generators by actor. 1`] = `
 Array [
   Object {

package/tests/feed-generation.test.ts

@@ -34,6 +34,7 @@ describe('feed generation', () => {
   let feedUriPrime: string // Taken-down
   let feedUriPrimeRef: RecordRef
   let feedUriNeedsAuth: string
+  let starterPackRef: { uri: string; cid: string }
 
   beforeAll(async () => {
     network = await TestNetwork.create({
@@ -251,6 +252,85 @@ describe('feed generation', () => {
     expect(forSnapshot(view.data.posts[0])).toMatchSnapshot()
   })
 
+  it('embeds starter pack records in posts', async () => {
+    const listRes = await pdsAgent.api.app.bsky.graph.list.create(
+      {
+        repo: sc.dids.alice,
+      },
+      {
+        name: 'awesome starter pack!',
+        description: '',
+        descriptionFacets: [],
+        avatar: undefined,
+        createdAt: new Date().toISOString(),
+        purpose: 'app.bsky.graph.defs#referencelist',
+      },
+      sc.getHeaders(sc.dids.alice),
+    )
+    const starterPackRes = await pdsAgent.api.app.bsky.graph.starterpack.create(
+      {
+        repo: sc.dids.alice,
+      },
+      {
+        name: 'awesome starter pack!',
+        description: '',
+        descriptionFacets: [],
+        feeds: [],
+        list: listRes.uri,
+        createdAt: new Date().toISOString(),
+      },
+      sc.getHeaders(sc.dids.alice),
+    )
+    starterPackRef = {
+      uri: starterPackRes.uri,
+      cid: starterPackRes.cid,
+    }
+    const res = await pdsAgent.api.app.bsky.feed.post.create(
+      { repo: sc.dids.bob },
+      {
+        text: 'sick starter pack!',
+        embed: {
+          $type: 'app.bsky.embed.record',
+          record: starterPackRef,
+        },
+        createdAt: new Date().toISOString(),
+      },
+      sc.getHeaders(sc.dids.bob),
+    )
+    await network.processAll()
+    const view = await agent.api.app.bsky.feed.getPosts(
+      { uris: [res.uri] },
+      { headers: await network.serviceHeaders(sc.dids.bob) },
+    )
+    expect(view.data.posts.length).toBe(1)
+    expect(forSnapshot(view.data.posts[0])).toMatchSnapshot()
+  })
+
+  it('does not embed taken-down starter pack records in posts', async () => {
+    await network.bsky.ctx.dataplane.takedownRecord({
+      recordUri: starterPackRef.uri,
+    })
+    const res = await pdsAgent.api.app.bsky.feed.post.create(
+      { repo: sc.dids.bob },
+      {
+        text: 'annoying starter pack',
+        embed: {
+          $type: 'app.bsky.embed.record',
+          record: starterPackRef,
+        },
+        createdAt: new Date().toISOString(),
+      },
+      sc.getHeaders(sc.dids.bob),
+    )
+    await network.processAll()
+    const view = await agent.api.app.bsky.feed.getPosts(
+      { uris: [res.uri] },
+      { headers: await network.serviceHeaders(sc.dids.bob) },
+    )
+    expect(view.data.posts.length).toBe(1)
+    expect(forSnapshot(view.data.posts[0])).toMatchSnapshot()
+  })
+
   describe('getFeedGenerator', () => {
     it('describes a feed gen & returns online status', async () => {
       const resEven = await agent.api.app.bsky.feed.getFeedGenerator(

package/tests/hydration/util.test.ts

@@ -0,0 +1,82 @@
+import {
+  HydrationMap,
+  mergeMaps,
+  mergeManyMaps,
+  mergeNestedMaps,
+} from '../../src/hydration/util'
+
+const mapToObj = (map: HydrationMap<any>) => {
+  const obj: Record<string, any> = {}
+  for (const [key, value] of map) {
+    obj[key] = value
+  }
+  return obj
+}
+
+describe('hydration util', () => {
+  it(`mergeMaps: merges two maps`, () => {
+    const compare = new HydrationMap<string>()
+    compare.set('a', 'a')
+    compare.set('b', 'b')
+
+    const a = new HydrationMap<string>().set('a', 'a')
+    const b = new HydrationMap<string>().set('b', 'b')
+    const merged = mergeMaps(a, b)
+
+    expect(mapToObj(merged!)).toEqual(mapToObj(compare))
+  })
+
+  it(`mergeManyMaps: merges three maps`, () => {
+    const compare = new HydrationMap<string>()
+    compare.set('a', 'a')
+    compare.set('b', 'b')
+    compare.set('c', 'c')
+
+    const a = new HydrationMap<string>().set('a', 'a')
+    const b = new HydrationMap<string>().set('b', 'b')
+    const c = new HydrationMap<string>().set('c', 'c')
+    const merged = mergeManyMaps(a, b, c)
+
+    expect(mapToObj(merged!)).toEqual(mapToObj(compare))
+  })
+
+  it(`mergeNestedMaps: merges two nested maps`, () => {
+    const compare = new HydrationMap<HydrationMap<string>>()
+    const compareA = new HydrationMap<string>().set('a', 'a')
+    const compareB = new HydrationMap<string>().set('b', 'b')
+    compare.set('a', compareA)
+    compare.set('b', compareB)
+
+    const a = new HydrationMap<HydrationMap<string>>().set(
+      'a',
+      new HydrationMap<string>().set('a', 'a'),
+    )
+    const b = new HydrationMap<HydrationMap<string>>().set(
+      'b',
+      new HydrationMap<string>().set('b', 'b'),
+    )
+    const merged = mergeNestedMaps(a, b)
+
+    expect(mapToObj(merged!)).toEqual(mapToObj(compare))
+  })
+
+  it(`mergeNestedMaps: merges two nested maps with common keys`, () => {
+    const compare = new HydrationMap<HydrationMap<boolean>>()
+    const compareA = new HydrationMap<boolean>()
+    compareA.set('b', true)
+    compareA.set('c', true)
+    compare.set('a', compareA)
+
+    const a = new HydrationMap<HydrationMap<boolean>>().set(
+      'a',
+      new HydrationMap<boolean>().set('b', true),
+    )
+    const b = new HydrationMap<HydrationMap<boolean>>().set(
+      'a',
+      new HydrationMap<boolean>().set('c', true),
+    )
+    const merged = mergeNestedMaps(a, b)
+
+    expect(mapToObj(merged!)).toEqual(mapToObj(compare))
+  })
+})

package/tests/seed/known-followers.ts

@@ -0,0 +1,110 @@
+import { TestNetwork, SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
+
+export type User = {
+  email: string
+  handle: string
+  password: string
+  displayName: string
+  description: string
+  selfLabels: undefined
+}
+
+function createUser(name: string): User {
+  return {
+    email: `${name}@test.com`,
+    handle: `${name}.test`,
+    password: `${name}-pass`,
+    displayName: name,
+    description: `hi im ${name} label_me`,
+    selfLabels: undefined,
+  }
+}
+
+const users = {
+  /*
+   * Base test. One known follower.
+   */
+  base_sub: createUser('base-sub'),
+  base_res_1: createUser('base-res-1'),
+  base_view: createUser('base-view'),
+
+  /*
+   * First-part block of a single known follower.
+   */
+  fp_block_sub: createUser('fp-block-sub'),
+  fp_block_res_1: createUser('fp-block-res-1'),
+  fp_block_view: createUser('fp-block-view'),
+
+  /*
+   * Second-party block of a single known follower.
+   */
+  sp_block_sub: createUser('sp-block-sub'),
+  sp_block_res_1: createUser('sp-block-res-1'),
+  sp_block_view: createUser('sp-block-view'),
+
+  /*
+   * Mix of known followers and blocks.
+   */
+  mix_sub_1: createUser('mix-sub-1'),
+  mix_sub_2: createUser('mix-sub-2'),
+  mix_sub_3: createUser('mix-sub-3'),
+  mix_res: createUser('mix-res'),
+  mix_fp_block_res: createUser('mix-fp-block-res'),
+  mix_sp_block_res: createUser('mix-sp-block-res'),
+  mix_view: createUser('mix-view'),
+}
+
+export async function knownFollowersSeed(
+  sc: SeedClient<TestNetwork | TestNetworkNoAppView>,
+) {
+  await sc.createAccount('base_sub', users.base_sub)
+  await sc.createAccount('base_res_1', users.base_res_1)
+  await sc.createAccount('base_view', users.base_view)
+
+  await sc.createAccount('fp_block_sub', users.fp_block_sub)
+  await sc.createAccount('fp_block_res_1', users.fp_block_res_1)
+  await sc.createAccount('fp_block_view', users.fp_block_view)
+
+  await sc.createAccount('sp_block_sub', users.sp_block_sub)
+  await sc.createAccount('sp_block_res_1', users.sp_block_res_1)
+  await sc.createAccount('sp_block_view', users.sp_block_view)
+
+  await sc.createAccount('mix_sub_1', users.mix_sub_1)
+  await sc.createAccount('mix_sub_2', users.mix_sub_2)
+  await sc.createAccount('mix_sub_3', users.mix_sub_3)
+  await sc.createAccount('mix_res', users.mix_res)
+  await sc.createAccount('mix_fp_block_res', users.mix_fp_block_res)
+  await sc.createAccount('mix_sp_block_res', users.mix_sp_block_res)
+  await sc.createAccount('mix_view', users.mix_view)
+
+  const dids = sc.dids
+
+  await sc.follow(dids.base_res_1, dids.base_sub)
+  await sc.follow(dids.base_view, dids.base_res_1)
+
+  await sc.follow(dids.fp_block_res_1, dids.fp_block_sub)
+  await sc.follow(dids.fp_block_view, dids.fp_block_res_1)
+
+  await sc.follow(dids.sp_block_res_1, dids.sp_block_sub)
+  await sc.follow(dids.sp_block_view, dids.sp_block_res_1)
+
+  await sc.follow(dids.mix_res, dids.mix_sub_1)
+  await sc.follow(dids.mix_res, dids.mix_sub_2)
+  await sc.follow(dids.mix_res, dids.mix_sub_3)
+  await sc.follow(dids.mix_fp_block_res, dids.mix_sub_1)
+  await sc.follow(dids.mix_fp_block_res, dids.mix_sub_2)
+  await sc.follow(dids.mix_fp_block_res, dids.mix_sub_3)
+  await sc.follow(dids.mix_sp_block_res, dids.mix_sub_1)
+  await sc.follow(dids.mix_sp_block_res, dids.mix_sub_2)
+  await sc.follow(dids.mix_sp_block_res, dids.mix_sub_3)
+  await sc.follow(dids.mix_view, dids.mix_res)
+  await sc.follow(dids.mix_view, dids.mix_fp_block_res)
+  await sc.follow(dids.mix_view, dids.mix_sp_block_res)
+
+  await sc.network.processAll()
+
+  return {
+    users,
+    seedClient: sc,
+  }
+}