@atproto/bsky 0.0.239 → 0.0.241

package/src/data-plane/server/indexing/plugins/post.ts

@@ -28,6 +28,7 @@ type PostEmbedImage = DatabaseSchemaType['post_embed_image']
 type PostEmbedExternal = DatabaseSchemaType['post_embed_external']
 type PostEmbedRecord = DatabaseSchemaType['post_embed_record']
 type PostEmbedVideo = DatabaseSchemaType['post_embed_video']
+type PostEmbedGalleryImage = DatabaseSchemaType['post_embed_gallery_image']
 type PostAncestor = {
   uri: string
   height: number
@@ -47,6 +48,7 @@ type IndexedPost = {
     | PostEmbedExternal
     | PostEmbedRecord
     | PostEmbedVideo
+    | PostEmbedGalleryImage[]
   )[]
   ancestors?: PostAncestor[]
   descendents?: PostDescendent[]
@@ -144,6 +146,7 @@ const insertFn = async (
     | PostEmbedExternal
     | PostEmbedRecord
     | PostEmbedVideo
+    | PostEmbedGalleryImage[]
   )[] = []
   const postEmbeds = separateEmbeds(obj.embed)
   for (const postEmbed of postEmbeds) {
@@ -238,6 +241,27 @@ const insertFn = async (
       embeds.push(videoEmbed)
 
       await db.insertInto('post_embed_video').values(videoEmbed).execute()
+    } else if (app.bsky.embed.gallery.$matches(postEmbed)) {
+      // Gallery items are a union; today only `#image` exists, but we
+      // defensively skip unknown variants for forward-compat.
+      const galleryImages: PostEmbedGalleryImage[] = []
+      postEmbed.items.forEach((item, i) => {
+        if (app.bsky.embed.gallery.image.$matches(item)) {
+          galleryImages.push({
+            postUri: uri.toString(),
+            position: i,
+            imageCid: getBlobCidString(item.image),
+            alt: item.alt,
+          })
+        }
+      })
+      if (galleryImages.length > 0) {
+        embeds.push(galleryImages)
+        await db
+          .insertInto('post_embed_gallery_image')
+          .values(galleryImages)
+          .execute()
+      }
     }
   }
 
@@ -381,8 +405,16 @@ const deleteFn = async (
     | PostEmbedImage[]
     | PostEmbedExternal
     | PostEmbedRecord
+    | PostEmbedVideo
+    | PostEmbedGalleryImage[]
   )[] = []
-  const [deletedImgs, deletedExternals, deletedPosts] = await Promise.all([
+  const [
+    deletedImgs,
+    deletedExternals,
+    deletedPosts,
+    deletedVideo,
+    deletedGalleryImgs,
+  ] = await Promise.all([
     db
       .deleteFrom('post_embed_image')
       .where('postUri', '=', uriStr)
@@ -398,6 +430,16 @@ const deleteFn = async (
       .where('postUri', '=', uriStr)
       .returningAll()
       .executeTakeFirst(),
+    db
+      .deleteFrom('post_embed_video')
+      .where('postUri', '=', uriStr)
+      .returningAll()
+      .executeTakeFirst(),
+    db
+      .deleteFrom('post_embed_gallery_image')
+      .where('postUri', '=', uriStr)
+      .returningAll()
+      .execute(),
   ])
   if (deletedImgs.length) {
     deletedEmbeds.push(deletedImgs)
@@ -405,6 +447,12 @@ const deleteFn = async (
   if (deletedExternals) {
     deletedEmbeds.push(deletedExternals)
   }
+  if (deletedVideo) {
+    deletedEmbeds.push(deletedVideo)
+  }
+  if (deletedGalleryImgs.length) {
+    deletedEmbeds.push(deletedGalleryImgs)
+  }
   if (deletedPosts) {
     const embedUri = new AtUri(deletedPosts.embedUri)
     deletedEmbeds.push(deletedPosts)

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

@@ -21,11 +21,24 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
         // only your own posts
         .where('type', '=', 'post')
         // only posts with media
-        .whereExists((qb) =>
+        .where((qb) =>
           qb
-            .selectFrom('post_embed_image')
-            .select('post_embed_image.postUri')
-            .whereRef('post_embed_image.postUri', '=', 'feed_item.postUri'),
+            .whereExists((iqb) =>
+              iqb
+                .selectFrom('post_embed_image')
+                .select('post_embed_image.postUri')
+                .whereRef('post_embed_image.postUri', '=', 'feed_item.postUri'),
+            )
+            .orWhereExists((iqb) =>
+              iqb
+                .selectFrom('post_embed_gallery_image')
+                .select('post_embed_gallery_image.postUri')
+                .whereRef(
+                  'post_embed_gallery_image.postUri',
+                  '=',
+                  'feed_item.postUri',
+                ),
+            ),
         )
     } else if (feedType === FeedType.POSTS_WITH_VIDEO) {
       builder = builder

package/src/hydration/hydrator.ts

@@ -334,29 +334,31 @@ export class Hydrator {
   async hydrateProfilesDetailed(
     dids: DidString[],
     ctx: HydrateCtx,
+    opts?: {
+      // when set, restricts known followers hydration to this subset of dids
+      knownFollowersDids?: DidString[]
+    },
   ): Promise<HydrationState> {
-    let knownFollowers: KnownFollowersStates = new HydrationMap()
-    try {
-      knownFollowers = await this.actor.getKnownFollowers(dids, ctx.viewer)
-    } catch (err) {
-      hydrationLogger.error(
-        { err },
-        'Failed to get known followers for profiles',
-      )
-    }
-
-    let activitySubscriptions: ActivitySubscriptionStates = new HydrationMap()
-    try {
-      activitySubscriptions = await this.actor.getActivitySubscriptions(
-        dids,
-        ctx.viewer,
-      )
-    } catch (err) {
-      hydrationLogger.error(
-        { err },
-        'Failed to get activity subscriptions state for profiles',
-      )
-    }
+    const [knownFollowers, activitySubscriptions] = await Promise.all([
+      this.actor
+        .getKnownFollowers(opts?.knownFollowersDids ?? dids, ctx.viewer)
+        .catch((err): KnownFollowersStates => {
+          hydrationLogger.error(
+            { err },
+            'Failed to get known followers for profiles',
+          )
+          return new HydrationMap()
+        }),
+      this.actor
+        .getActivitySubscriptions(dids, ctx.viewer)
+        .catch((err): ActivitySubscriptionStates => {
+          hydrationLogger.error(
+            { err },
+            'Failed to get activity subscriptions state for profiles',
+          )
+          return new HydrationMap()
+        }),
+    ])
 
     const subjectsToKnownFollowersMap = new Map<DidString, DidString[]>()
 
@@ -1051,12 +1053,11 @@ export class Hydrator {
         )
       },
     )
-    const blocks = await this.hydrateBidirectionalBlocks(
-      pairsToMap(listCreatorMemberPairs),
-      ctx,
-    )
-    // sample top list items per starter pack based on their follows
-    const listMemberAggs = await this.actor.getProfileAggregates(listMemberDids)
+    const [blocks, listMemberAggs] = await Promise.all([
+      this.hydrateBidirectionalBlocks(pairsToMap(listCreatorMemberPairs), ctx),
+      // sample top list items per starter pack based on their follows
+      this.actor.getProfileAggregates(listMemberDids),
+    ])
     const listItemUris: AtUriString[] = []
     uris.forEach((uri) => {
       const sp = starterPackState.starterPacks?.get(uri)

package/tests/views/author-feed.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import {
   AppBskyActorProfile,
+  AppBskyEmbedGallery,
   AppBskyEmbedImages,
   AppBskyEmbedRecordWithMedia,
   AppBskyEmbedVideo,
@@ -395,6 +396,52 @@ describe('pds author feed views', () => {
     expect(danFeed.feed.length).toEqual(0)
   })
 
+  it('includes gallery posts in posts_with_media', async () => {
+    const { data: blob1 } = await pdsAgent.api.com.atproto.repo.uploadBlob(
+      Buffer.from('gallery-image-1'),
+      {
+        headers: sc.getHeaders(sc.dids.dan),
+        encoding: 'image/jpeg',
+      },
+    )
+    const { data: blob2 } = await pdsAgent.api.com.atproto.repo.uploadBlob(
+      Buffer.from('gallery-image-2'),
+      {
+        headers: sc.getHeaders(sc.dids.dan),
+        encoding: 'image/jpeg',
+      },
+    )
+
+    await sc.post(dan, 'gallery post', undefined, undefined, undefined, {
+      embed: {
+        $type: 'app.bsky.embed.gallery',
+        items: [
+          {
+            $type: 'app.bsky.embed.gallery#image',
+            image: blob1.blob,
+            alt: 'first',
+            aspectRatio: { height: 1, width: 1 },
+          },
+          {
+            $type: 'app.bsky.embed.gallery#image',
+            image: blob2.blob,
+            alt: 'second',
+            aspectRatio: { height: 1, width: 1 },
+          },
+        ],
+      },
+    })
+    await network.processAll()
+
+    const { data: danFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
+      actor: dan,
+      filter: 'posts_with_media',
+    })
+
+    expect(danFeed.feed.length).toEqual(1)
+    assert(AppBskyEmbedGallery.isView(danFeed.feed[0].post.embed))
+  })
+
   it('filters by posts_no_replies', async () => {
     const { data: carolFeed } = await agent.api.app.bsky.feed.getAuthorFeed({
       actor: carol,

package/tests/views/internal-actor.test.ts

@@ -0,0 +1,129 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { AppBskyActorDefs, AtpAgent } from '@atproto/api'
+import { SeedClient, TestNetwork } from '@atproto/dev-env'
+import { knownFollowersSeed } from '../seed/known-followers.js'
+
+describe('internal actor views', () => {
+  let network: TestNetwork
+  let pdsAgent: AtpAgent
+  let seedClient: SeedClient
+
+  let dids: Record<string, string>
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'bsky_internal_actor',
+    })
+    pdsAgent = network.pds.getAgent()
+    seedClient = network.getSeedClient()
+
+    await knownFollowersSeed(seedClient)
+
+    dids = seedClient.dids
+
+    /*
+     * Mix of blocks and non, mirroring the known-followers test setup so the
+     * social proof results exercise block filtering too.
+     */
+    await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: dids.mix_view },
+      { createdAt: new Date().toISOString(), subject: dids.mix_fp_block_res },
+      seedClient.getHeaders(dids.mix_view),
+    )
+    await pdsAgent.api.app.bsky.graph.block.create(
+      { repo: dids.mix_sub_1 },
+      { createdAt: new Date().toISOString(), subject: dids.mix_sp_block_res },
+      seedClient.getHeaders(dids.mix_sub_1),
+    )
+
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  describe('getProfiles', () => {
+    const getProfiles = async (
+      params: { dids: string[]; socialProof?: string[]; viewer?: string },
+      headers: Record<string, string> = network.bsky.adminAuthHeaders(),
+    ) => {
+      const search = new URLSearchParams()
+      params.dids.forEach((did) => search.append('dids', did))
+      params.socialProof?.forEach((did) => search.append('socialProof', did))
+      if (params.viewer) search.append('viewer', params.viewer)
+      const res = await fetch(
+        `${network.bsky.url}/xrpc/internal.bsky.actor.getProfiles?${search.toString()}`,
+        { headers },
+      )
+      return {
+        status: res.status,
+        body: (await res.json()) as {
+          profiles: AppBskyActorDefs.ProfileViewDetailed[]
+        },
+      }
+    }
+
+    it('requires role auth, rejecting standard user auth', async () => {
+      const userHeaders = await network.serviceHeaders(
+        dids.mix_view,
+        'internal.bsky.actor.getProfiles',
+      )
+      const { status } = await getProfiles(
+        { dids: [dids.mix_sub_1] },
+        userHeaders,
+      )
+      expect(status).toBe(401)
+    })
+
+    it('returns all profiles, with social proof only for the requested subset', async () => {
+      const { status, body } = await getProfiles({
+        dids: [dids.mix_sub_1, dids.mix_sub_2, dids.mix_sub_3],
+        socialProof: [dids.mix_sub_1],
+        viewer: dids.mix_view,
+      })
+      expect(status).toBe(200)
+      expect(body.profiles).toHaveLength(3)
+
+      const [sub_1, sub_2, sub_3] = body.profiles
+      expect(sub_1.viewer?.knownFollowers?.count).toBe(3)
+      expect(sub_1.viewer?.knownFollowers?.followers).toHaveLength(1)
+      expect(sub_2.viewer?.knownFollowers).toBeUndefined()
+      expect(sub_3.viewer?.knownFollowers).toBeUndefined()
+    })
+
+    it('ignores socialProof dids that are not in dids', async () => {
+      const { status, body } = await getProfiles({
+        dids: [dids.mix_sub_1],
+        socialProof: [dids.mix_sub_1, dids.mix_sub_2],
+        viewer: dids.mix_view,
+      })
+      expect(status).toBe(200)
+      expect(body.profiles).toHaveLength(1)
+      expect(body.profiles[0].did).toBe(dids.mix_sub_1)
+      expect(body.profiles[0].viewer?.knownFollowers?.count).toBe(3)
+    })
+
+    it('returns no social proof when socialProof is omitted', async () => {
+      const { status, body } = await getProfiles({
+        dids: [dids.mix_sub_1, dids.mix_sub_2],
+        viewer: dids.mix_view,
+      })
+      expect(status).toBe(200)
+      expect(body.profiles).toHaveLength(2)
+      for (const profile of body.profiles) {
+        expect(profile.viewer?.knownFollowers).toBeUndefined()
+      }
+    })
+
+    it('returns no viewer state when viewer is omitted', async () => {
+      const { status, body } = await getProfiles({
+        dids: [dids.mix_sub_1],
+        socialProof: [dids.mix_sub_1],
+      })
+      expect(status).toBe(200)
+      expect(body.profiles).toHaveLength(1)
+      expect(body.profiles[0].viewer).toBeUndefined()
+    })
+  })
+})