@atproto/bsky 0.0.94 → 0.0.95

package/src/proto/bsky_pb.ts

@@ -9445,6 +9445,143 @@ export class SearchPostsResponse extends Message<SearchPostsResponse> {
   }
 }
 
+/**
+ * - Return uris of starter packs matching term, paginated
+ *     - `searchStarterPacks` skeleton
+ *
+ * @generated from message bsky.SearchStarterPacksRequest
+ */
+export class SearchStarterPacksRequest extends Message<SearchStarterPacksRequest> {
+  /**
+   * @generated from field: string term = 1;
+   */
+  term = ''
+
+  /**
+   * @generated from field: int32 limit = 2;
+   */
+  limit = 0
+
+  /**
+   * @generated from field: string cursor = 3;
+   */
+  cursor = ''
+
+  constructor(data?: PartialMessage<SearchStarterPacksRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsky.SearchStarterPacksRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'term', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'limit', kind: 'scalar', T: 5 /* ScalarType.INT32 */ },
+    { no: 3, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): SearchStarterPacksRequest {
+    return new SearchStarterPacksRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): SearchStarterPacksRequest {
+    return new SearchStarterPacksRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): SearchStarterPacksRequest {
+    return new SearchStarterPacksRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | SearchStarterPacksRequest
+      | PlainMessage<SearchStarterPacksRequest>
+      | undefined,
+    b:
+      | SearchStarterPacksRequest
+      | PlainMessage<SearchStarterPacksRequest>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(SearchStarterPacksRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsky.SearchStarterPacksResponse
+ */
+export class SearchStarterPacksResponse extends Message<SearchStarterPacksResponse> {
+  /**
+   * @generated from field: repeated string uris = 1;
+   */
+  uris: string[] = []
+
+  /**
+   * @generated from field: string cursor = 2;
+   */
+  cursor = ''
+
+  constructor(data?: PartialMessage<SearchStarterPacksResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsky.SearchStarterPacksResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: 'uris',
+      kind: 'scalar',
+      T: 9 /* ScalarType.STRING */,
+      repeated: true,
+    },
+    { no: 2, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): SearchStarterPacksResponse {
+    return new SearchStarterPacksResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): SearchStarterPacksResponse {
+    return new SearchStarterPacksResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): SearchStarterPacksResponse {
+    return new SearchStarterPacksResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | SearchStarterPacksResponse
+      | PlainMessage<SearchStarterPacksResponse>
+      | undefined,
+    b:
+      | SearchStarterPacksResponse
+      | PlainMessage<SearchStarterPacksResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(SearchStarterPacksResponse, a, b)
+  }
+}
+
 /**
  * - Return DIDs of suggested follows for a user, excluding anyone they already follow
  *     - `getSuggestions`, `getSuggestedFollowsByActor`

package/src/views/index.ts

@@ -125,6 +125,15 @@ export class Views {
     return actor.muted || !!actor.mutedByList
   }
 
+  viewerSeesNeedsReview(did: string, state: HydrationState): boolean {
+    const { labels, profileViewers, ctx } = state
+    return (
+      !labels?.get(did)?.needsReview ||
+      ctx?.viewer === did ||
+      !!profileViewers?.get(did)?.following
+    )
+  }
+
   replyIsHiddenByThreadgate(
     replyUri: string,
     rootPostUri: string,
@@ -850,6 +859,9 @@ export class Views {
       if (this.viewerBlockExists(post.author.did, state)) {
         return this.blockedPost(uri, post.author.did, state)
       }
+      if (!this.viewerSeesNeedsReview(post.author.did, state)) {
+        return undefined
+      }
       return {
         $type: 'app.bsky.feed.defs#threadViewPost',
         post,

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

@@ -397,9 +397,9 @@ Array [
         "muted": false,
       },
     },
-    "description": "Provides all feed candidates, blindly ignoring pagination limit",
+    "description": "Echoes back the same cursor it received",
     "did": "user(0)",
-    "displayName": "Bad Pagination",
+    "displayName": "Bad Pagination Cursor",
     "indexedAt": "1970-01-01T00:00:00.000Z",
     "labels": Array [],
     "likeCount": 0,
@@ -439,9 +439,9 @@ Array [
         "muted": false,
       },
     },
-    "description": "Provides even-indexed feed candidates",
+    "description": "Provides all feed candidates, blindly ignoring pagination limit",
     "did": "user(0)",
-    "displayName": "Even",
+    "displayName": "Bad Pagination Limit",
     "indexedAt": "1970-01-01T00:00:00.000Z",
     "labels": Array [],
     "likeCount": 0,
@@ -481,15 +481,57 @@ Array [
         "muted": false,
       },
     },
+    "description": "Provides even-indexed feed candidates",
+    "did": "user(0)",
+    "displayName": "Even",
+    "indexedAt": "1970-01-01T00:00:00.000Z",
+    "labels": Array [],
+    "likeCount": 0,
+    "uri": "record(7)",
+    "viewer": Object {},
+  },
+  Object {
+    "cid": "cids(7)",
+    "creator": Object {
+      "avatar": "https://bsky.public.url/img/avatar/plain/user(2)/cids(1)@jpeg",
+      "createdAt": "1970-01-01T00:00:00.000Z",
+      "description": "its me!",
+      "did": "user(1)",
+      "displayName": "ali",
+      "handle": "alice.test",
+      "indexedAt": "1970-01-01T00:00:00.000Z",
+      "labels": Array [
+        Object {
+          "cid": "cids(2)",
+          "cts": "1970-01-01T00:00:00.000Z",
+          "src": "user(1)",
+          "uri": "record(3)",
+          "val": "self-label-a",
+        },
+        Object {
+          "cid": "cids(2)",
+          "cts": "1970-01-01T00:00:00.000Z",
+          "src": "user(1)",
+          "uri": "record(3)",
+          "val": "self-label-b",
+        },
+      ],
+      "viewer": Object {
+        "blockedBy": false,
+        "followedBy": "record(2)",
+        "following": "record(1)",
+        "muted": false,
+      },
+    },
     "description": "Provides all feed candidates",
     "did": "user(0)",
     "displayName": "All",
     "indexedAt": "1970-01-01T00:00:00.000Z",
     "labels": Array [],
     "likeCount": 2,
-    "uri": "record(7)",
+    "uri": "record(8)",
     "viewer": Object {
-      "like": "record(8)",
+      "like": "record(9)",
     },
   },
 ]
@@ -1950,7 +1992,7 @@ Object {
       },
       "description": "Provides all feed candidates, blindly ignoring pagination limit",
       "did": "user(0)",
-      "displayName": "Bad Pagination",
+      "displayName": "Bad Pagination Limit",
       "indexedAt": "1970-01-01T00:00:00.000Z",
       "labels": Array [],
       "likeCount": 0,

package/tests/feed-generation.test.ts

@@ -30,7 +30,8 @@ describe('feed generation', () => {
   let feedUriAllRef: RecordRef
   let feedUriEven: string
   let feedUriOdd: string // Unsupported by feed gen
-  let feedUriBadPagination: string
+  let feedUriBadPaginationLimit: string
+  let feedUriBadPaginationCursor: string
   let feedUriPrime: string // Taken-down
   let feedUriPrimeRef: RecordRef
   let feedUriNeedsAuth: string
@@ -47,10 +48,15 @@ describe('feed generation', () => {
     await network.processAll()
     alice = sc.dids.alice
     const allUri = AtUri.make(alice, 'app.bsky.feed.generator', 'all')
-    const feedUriBadPagination = AtUri.make(
+    const feedUriBadPaginationLimit = AtUri.make(
       alice,
       'app.bsky.feed.generator',
-      'bad-pagination',
+      'bad-pagination-limit',
+    )
+    const feedUriBadPaginationCursor = AtUri.make(
+      alice,
+      'app.bsky.feed.generator',
+      'bad-pagination-cursor',
     )
     const evenUri = AtUri.make(alice, 'app.bsky.feed.generator', 'even')
     const primeUri = AtUri.make(alice, 'app.bsky.feed.generator', 'prime')
@@ -62,7 +68,12 @@ describe('feed generation', () => {
     gen = await network.createFeedGen({
       [allUri.toString()]: feedGenHandler('all'),
       [evenUri.toString()]: feedGenHandler('even'),
-      [feedUriBadPagination.toString()]: feedGenHandler('bad-pagination'),
+      [feedUriBadPaginationLimit.toString()]: feedGenHandler(
+        'bad-pagination-limit',
+      ),
+      [feedUriBadPaginationCursor.toString()]: feedGenHandler(
+        'bad-pagination-cursor',
+      ),
       [primeUri.toString()]: feedGenHandler('prime'),
       [needsAuthUri.toString()]: feedGenHandler('needs-auth'),
     })
@@ -70,7 +81,7 @@ describe('feed generation', () => {
     const feedSuggestions = [
       { uri: allUri.toString(), order: 1 },
       { uri: evenUri.toString(), order: 2 },
-      { uri: feedUriBadPagination.toString(), order: 3 },
+      { uri: feedUriBadPaginationLimit.toString(), order: 3 },
       { uri: primeUri.toString(), order: 4 },
     ]
     await network.bsky.db.db
@@ -116,17 +127,31 @@ describe('feed generation', () => {
       },
       sc.getHeaders(alice),
     )
-    const badPagination = await pdsAgent.api.app.bsky.feed.generator.create(
-      { repo: alice, rkey: 'bad-pagination' },
-      {
-        did: gen.did,
-        displayName: 'Bad Pagination',
-        description:
-          'Provides all feed candidates, blindly ignoring pagination limit',
-        createdAt: new Date().toISOString(),
-      },
-      sc.getHeaders(alice),
-    )
+
+    const badPaginationLimit =
+      await pdsAgent.api.app.bsky.feed.generator.create(
+        { repo: alice, rkey: 'bad-pagination-limit' },
+        {
+          did: gen.did,
+          displayName: 'Bad Pagination Limit',
+          description:
+            'Provides all feed candidates, blindly ignoring pagination limit',
+          createdAt: new Date().toISOString(),
+        },
+        sc.getHeaders(alice),
+      )
+    const badPaginationCursor =
+      await pdsAgent.api.app.bsky.feed.generator.create(
+        { repo: alice, rkey: 'bad-pagination-cursor' },
+        {
+          did: gen.did,
+          displayName: 'Bad Pagination Cursor',
+          description: 'Echoes back the same cursor it received',
+          createdAt: new Date().toISOString(),
+        },
+        sc.getHeaders(alice),
+      )
+
     // Taken-down
     const prime = await pdsAgent.api.app.bsky.feed.generator.create(
       { repo: alice, rkey: 'prime' },
@@ -157,7 +182,8 @@ describe('feed generation', () => {
     feedUriAllRef = new RecordRef(all.uri, all.cid)
     feedUriEven = even.uri
     feedUriOdd = odd.uri
-    feedUriBadPagination = badPagination.uri
+    feedUriBadPaginationLimit = badPaginationLimit.uri
+    feedUriBadPaginationCursor = badPaginationCursor.uri
     feedUriPrime = prime.uri
     feedUriPrimeRef = new RecordRef(prime.uri, prime.cid)
     feedUriNeedsAuth = needsAuth.uri
@@ -203,12 +229,13 @@ describe('feed generation', () => {
 
     const paginatedAll = results(await paginateAll(paginator))
 
-    expect(paginatedAll.length).toEqual(5)
+    expect(paginatedAll.length).toEqual(6)
     expect(paginatedAll[0].uri).toEqual(feedUriOdd)
     expect(paginatedAll[1].uri).toEqual(feedUriNeedsAuth)
-    expect(paginatedAll[2].uri).toEqual(feedUriBadPagination)
-    expect(paginatedAll[3].uri).toEqual(feedUriEven)
-    expect(paginatedAll[4].uri).toEqual(feedUriAll)
+    expect(paginatedAll[2].uri).toEqual(feedUriBadPaginationCursor)
+    expect(paginatedAll[3].uri).toEqual(feedUriBadPaginationLimit)
+    expect(paginatedAll[4].uri).toEqual(feedUriEven)
+    expect(paginatedAll[5].uri).toEqual(feedUriAll)
     expect(paginatedAll.map((fg) => fg.uri)).not.toContain(feedUriPrime) // taken-down
     expect(forSnapshot(paginatedAll)).toMatchSnapshot()
   })
@@ -490,7 +517,7 @@ describe('feed generation', () => {
       expect(res.data.feeds.map((f) => f.uri)).toEqual([
         feedUriAll,
         feedUriEven,
-        feedUriBadPagination,
+        feedUriBadPaginationLimit,
       ])
     })
 
@@ -605,7 +632,7 @@ describe('feed generation', () => {
 
     it('paginates, handling feed not respecting limit.', async () => {
       const res = await agent.api.app.bsky.feed.getFeed(
-        { feed: feedUriBadPagination, limit: 3 },
+        { feed: feedUriBadPaginationLimit, limit: 3 },
         {
           headers: await network.serviceHeaders(
             alice,
@@ -640,6 +667,22 @@ describe('feed generation', () => {
       })
     })
 
+    it('returns empty cursor with feeds that echo back the same cursor from the param.', async () => {
+      const res = await agent.api.app.bsky.feed.getFeed(
+        { feed: feedUriBadPaginationCursor, cursor: '1', limit: 2 },
+        {
+          headers: await network.serviceHeaders(
+            alice,
+            ids.AppBskyFeedGetFeed,
+            gen.did,
+          ),
+        },
+      )
+
+      expect(res.data.cursor).toBeUndefined()
+      expect(res.data.feed).toHaveLength(2)
+    })
+
     it('resolves contents of taken-down feed.', async () => {
       const tryGetFeed = agent.api.app.bsky.feed.getFeed(
         { feed: feedUriPrime },
@@ -712,7 +755,13 @@ describe('feed generation', () => {
 
   const feedGenHandler =
     (
-      feedName: 'even' | 'all' | 'prime' | 'bad-pagination' | 'needs-auth',
+      feedName:
+        | 'even'
+        | 'all'
+        | 'prime'
+        | 'bad-pagination-limit'
+        | 'bad-pagination-cursor'
+        | 'needs-auth',
     ): SkeletonHandler =>
     async ({ req, params }) => {
       if (feedName === 'needs-auth' && !req.headers.authorization) {
@@ -753,17 +802,22 @@ describe('feed generation', () => {
         return true
       })
       const feedResults =
-        feedName === 'bad-pagination'
+        feedName === 'bad-pagination-limit'
           ? fullFeed.slice(offset) // does not respect limit
           : fullFeed.slice(offset, offset + limit)
       const lastResult = feedResults.at(-1)
+      const cursorResult =
+        feedName === 'bad-pagination-cursor'
+          ? cursor
+          : lastResult
+            ? (fullFeed.indexOf(lastResult) + 1).toString()
+            : undefined
+
       return {
         encoding: 'application/json',
         body: {
           feed: feedResults,
-          cursor: lastResult
-            ? (fullFeed.indexOf(lastResult) + 1).toString()
-            : undefined,
+          cursor: cursorResult,
           $auth: jwtBody(req.headers.authorization), // for testing purposes
         },
       }

package/tests/query-labels.test.ts

@@ -13,7 +13,7 @@ describe('label hydration', () => {
 
   beforeAll(async () => {
     network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_label_hydration',
+      dbPostgresSchema: 'bsky_query_labels',
     })
     pdsAgent = network.pds.getClient()
     sc = network.getSeedClient()

package/tests/views/known-followers.test.ts

@@ -14,7 +14,7 @@ describe('known followers (social proof)', () => {
 
   beforeAll(async () => {
     network = await TestNetwork.create({
-      dbPostgresSchema: 'bsky_views_block',
+      dbPostgresSchema: 'bsky_known_followers',
     })
     agent = network.bsky.getClient()
     pdsAgent = network.pds.getClient()

package/tests/views/labels-needs-review.test.ts

@@ -0,0 +1,168 @@
+import { AtpAgent } from '@atproto/api'
+import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
+import { ids } from '../../src/lexicon/lexicons'
+import assert from 'assert'
+import { isThreadViewPost } from '../../src/lexicon/types/app/bsky/feed/defs'
+
+describe('bsky needs-review labels', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_views_needs_review_labels',
+    })
+    agent = network.bsky.getClient()
+    sc = network.getSeedClient()
+    await basicSeed(sc)
+
+    await sc.createAccount('geoff', {
+      email: 'geoff@test.com',
+      handle: 'geoff.test',
+      password: 'geoff',
+    })
+
+    await sc.reply(
+      sc.dids.geoff,
+      sc.posts[sc.dids.alice][0].ref,
+      sc.posts[sc.dids.alice][0].ref,
+      'my name geoff',
+    )
+
+    await sc.post(
+      sc.dids.geoff,
+      'her name alice',
+      undefined,
+      undefined,
+      sc.posts[sc.dids.alice][0].ref,
+    )
+
+    await sc.follow(sc.dids.bob, sc.dids.geoff)
+
+    await network.processAll()
+
+    AtpAgent.configure({ appLabelers: [network.ozone.ctx.cfg.service.did] })
+    await network.bsky.db.db
+      .insertInto('label')
+      .values({
+        src: network.ozone.ctx.cfg.service.did,
+        uri: sc.dids.geoff,
+        cid: '',
+        val: 'needs-review',
+        neg: false,
+        cts: new Date().toISOString(),
+      })
+      .execute()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('applies to thread replies.', async () => {
+    const {
+      data: { thread },
+    } = await agent.app.bsky.feed.getPostThread({
+      uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+    })
+    assert(isThreadViewPost(thread))
+    expect(
+      thread.replies?.some((reply) => {
+        return (
+          isThreadViewPost(reply) && reply.post.author.did === sc.dids.geoff
+        )
+      }),
+    ).toBe(false)
+  })
+
+  it('applies to quote lists.', async () => {
+    const {
+      data: { posts },
+    } = await agent.app.bsky.feed.getQuotes({
+      uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+    })
+    expect(
+      posts.some((post) => {
+        return post.author.did === sc.dids.geoff
+      }),
+    ).toBe(false)
+  })
+
+  it('applies to reply, quote, and mention notifications.', async () => {
+    const {
+      data: { notifications },
+    } = await agent.app.bsky.notification.listNotifications(
+      {},
+      {
+        headers: await network.serviceHeaders(
+          sc.dids.alice,
+          ids.AppBskyNotificationListNotifications,
+        ),
+      },
+    )
+    expect(
+      notifications.some((notif) => {
+        return notif.reason === 'reply' && notif.author.did === sc.dids.geoff
+      }),
+    ).toBe(false)
+    expect(
+      notifications.some((notif) => {
+        return notif.reason === 'quote' && notif.author.did === sc.dids.geoff
+      }),
+    ).toBe(false)
+    expect(
+      notifications.some((notif) => {
+        return notif.reason === 'mention' && notif.author.did === sc.dids.geoff
+      }),
+    ).toBe(false)
+  })
+
+  it('does not apply to self.', async () => {
+    const {
+      data: { thread },
+    } = await agent.app.bsky.feed.getPostThread(
+      {
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+      },
+      {
+        headers: await network.serviceHeaders(
+          sc.dids.geoff,
+          ids.AppBskyFeedGetPostThread,
+        ),
+      },
+    )
+    assert(isThreadViewPost(thread))
+    expect(
+      thread.replies?.some((reply) => {
+        return (
+          isThreadViewPost(reply) && reply.post.author.did === sc.dids.geoff
+        )
+      }),
+    ).toBe(true)
+  })
+
+  it('does not apply to followers.', async () => {
+    const {
+      data: { thread },
+    } = await agent.app.bsky.feed.getPostThread(
+      {
+        uri: sc.posts[sc.dids.alice][0].ref.uriStr,
+      },
+      {
+        headers: await network.serviceHeaders(
+          sc.dids.bob, // follows geoff
+          ids.AppBskyFeedGetPostThread,
+        ),
+      },
+    )
+    assert(isThreadViewPost(thread))
+    expect(
+      thread.replies?.some((reply) => {
+        return (
+          isThreadViewPost(reply) && reply.post.author.did === sc.dids.geoff
+        )
+      }),
+    ).toBe(true)
+  })
+})