@atproto/bsky 0.0.76 → 0.0.77

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

@@ -17,6 +17,7 @@ import { Database } from '../db'
 import { Actor } from '../db/tables/actor'
 import * as Post from './plugins/post'
 import * as Threadgate from './plugins/thread-gate'
+import * as Postgate from './plugins/post-gate'
 import * as Like from './plugins/like'
 import * as Repost from './plugins/repost'
 import * as Follow from './plugins/follow'
@@ -38,6 +39,7 @@ export class IndexingService {
   records: {
     post: Post.PluginType
     threadGate: Threadgate.PluginType
+    postGate: Postgate.PluginType
     like: Like.PluginType
     repost: Repost.PluginType
     follow: Follow.PluginType
@@ -60,6 +62,7 @@ export class IndexingService {
     this.records = {
       post: Post.makePlugin(this.db, this.background),
       threadGate: Threadgate.makePlugin(this.db, this.background),
+      postGate: Postgate.makePlugin(this.db, this.background),
       like: Like.makePlugin(this.db, this.background),
       repost: Repost.makePlugin(this.db, this.background),
       follow: Follow.makePlugin(this.db, this.background),
@@ -365,6 +368,10 @@ export class IndexingService {
       .deleteFrom('thread_gate')
       .where('creator', '=', did)
       .execute()
+    await this.db.db
+      .deleteFrom('post_gate')
+      .where('creator', '=', did)
+      .execute()
     // notifications
     await this.db.db
       .deleteFrom('notification')

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

@@ -0,0 +1,104 @@
+import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { CID } from 'multiformats/cid'
+import * as Postgate from '../../../../lexicon/types/app/bsky/feed/postgate'
+import * as lex from '../../../../lexicon/lexicons'
+import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema'
+import { Database } from '../../db'
+import RecordProcessor from '../processor'
+import { BackgroundQueue } from '../../background'
+
+const lexId = lex.ids.AppBskyFeedPostgate
+type IndexedGate = DatabaseSchemaType['post_gate']
+
+const insertFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+  cid: CID,
+  obj: Postgate.Record,
+  timestamp: string,
+): Promise<IndexedGate | null> => {
+  const postUri = new AtUri(obj.post)
+  if (postUri.host !== uri.host || postUri.rkey !== uri.rkey) {
+    throw new InvalidRequestError(
+      'Creator and rkey of post gate does not match its post',
+    )
+  }
+  const inserted = await db
+    .insertInto('post_gate')
+    .values({
+      uri: uri.toString(),
+      cid: cid.toString(),
+      creator: uri.host,
+      postUri: obj.post,
+      createdAt: normalizeDatetimeAlways(obj.createdAt),
+      indexedAt: timestamp,
+    })
+    .onConflict((oc) => oc.doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  await db
+    .updateTable('post')
+    .where('uri', '=', postUri.toString())
+    .set({ hasPostGate: true })
+    .executeTakeFirst()
+  return inserted || null
+}
+
+const findDuplicate = async (
+  db: DatabaseSchema,
+  _uri: AtUri,
+  obj: Postgate.Record,
+): Promise<AtUri | null> => {
+  const found = await db
+    .selectFrom('post_gate')
+    .where('postUri', '=', obj.post)
+    .selectAll()
+    .executeTakeFirst()
+  return found ? new AtUri(found.uri) : null
+}
+
+const notifsForInsert = () => {
+  return []
+}
+
+const deleteFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+): Promise<IndexedGate | null> => {
+  const deleted = await db
+    .deleteFrom('post_gate')
+    .where('uri', '=', uri.toString())
+    .returningAll()
+    .executeTakeFirst()
+  if (deleted) {
+    await db
+      .updateTable('post')
+      .where('uri', '=', deleted.postUri)
+      .set({ hasPostGate: false })
+      .executeTakeFirst()
+  }
+  return deleted || null
+}
+
+const notifsForDelete = () => {
+  return { notifs: [], toDelete: [] }
+}
+
+export type PluginType = RecordProcessor<Postgate.Record, IndexedGate>
+
+export const makePlugin = (
+  db: Database,
+  background: BackgroundQueue,
+): PluginType => {
+  return new RecordProcessor(db, background, {
+    lexId,
+    insertFn,
+    findDuplicate,
+    deleteFn,
+    notifsForInsert,
+    notifsForDelete,
+  })
+}
+
+export default makePlugin

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

@@ -7,6 +7,7 @@ import {
   ReplyRef,
 } from '../../../../lexicon/types/app/bsky/feed/post'
 import { Record as GateRecord } from '../../../../lexicon/types/app/bsky/feed/threadgate'
+import { Record as PostgateRecord } from '../../../../lexicon/types/app/bsky/feed/postgate'
 import { isMain as isEmbedImage } from '../../../../lexicon/types/app/bsky/embed/images'
 import { isMain as isEmbedExternal } from '../../../../lexicon/types/app/bsky/embed/external'
 import { isMain as isEmbedRecord } from '../../../../lexicon/types/app/bsky/embed/record'
@@ -26,9 +27,14 @@ import {
   getDescendentsQb,
   invalidReplyRoot as checkInvalidReplyRoot,
   violatesThreadGate as checkViolatesThreadGate,
-  postToThreadgateUri,
 } from '../../util'
 import { BackgroundQueue } from '../../background'
+import { parsePostgate } from '../../../../views/util'
+import {
+  postUriToThreadgateUri,
+  postUriToPostgateUri,
+  uriToDid,
+} from '../../../../util/uris'
 
 type Notif = Insertable<Notification>
 type Post = Selectable<DatabaseSchemaType['post']>
@@ -52,6 +58,7 @@ type IndexedPost = {
   embeds?: (PostEmbedImage[] | PostEmbedExternal | PostEmbedRecord)[]
   ancestors?: PostAncestor[]
   descendents?: PostDescendent[]
+  threadgate?: GateRecord
 }
 
 const lexId = lex.ids.AppBskyFeedPost
@@ -168,6 +175,7 @@ const insertFn = async (
       await db.insertInto('post_embed_external').values(externalEmbed).execute()
     } else if (isEmbedRecord(postEmbed)) {
       const { record } = postEmbed
+      const embedUri = new AtUri(record.uri)
       const recordEmbed = {
         postUri: uri.toString(),
         embedUri: record.uri,
@@ -175,9 +183,59 @@ const insertFn = async (
       }
       embeds.push(recordEmbed)
       await db.insertInto('post_embed_record').values(recordEmbed).execute()
+
+      if (embedUri.collection === lex.ids.AppBskyFeedPost) {
+        const quote = {
+          uri: uri.toString(),
+          cid: cid.toString(),
+          subject: record.uri,
+          subjectCid: record.cid,
+          createdAt: normalizeDatetimeAlways(obj.createdAt),
+          indexedAt: timestamp,
+        }
+        await db
+          .insertInto('quote')
+          .values(quote)
+          .onConflict((oc) => oc.doNothing())
+          .returningAll()
+          .executeTakeFirst()
+
+        const quoteCountQb = db
+          .insertInto('post_agg')
+          .values({
+            uri: record.uri.toString(),
+            quoteCount: db
+              .selectFrom('quote')
+              .where('quote.subjectCid', '=', record.cid.toString())
+              .select(countAll.as('count')),
+          })
+          .onConflict((oc) =>
+            oc
+              .column('uri')
+              .doUpdateSet({ quoteCount: excluded(db, 'quoteCount') }),
+          )
+        await quoteCountQb.execute()
+
+        const { violatesEmbeddingRules } = await validatePostEmbed(
+          db,
+          embedUri.toString(),
+          uri.toString(),
+        )
+        Object.assign(insertedPost, {
+          violatesEmbeddingRules: violatesEmbeddingRules,
+        })
+        if (violatesEmbeddingRules) {
+          await db
+            .updateTable('post')
+            .where('uri', '=', insertedPost.uri)
+            .set({ violatesEmbeddingRules: violatesEmbeddingRules })
+            .executeTakeFirst()
+        }
+      }
     }
   }
 
+  const threadgate = await getThreadgateRecord(db, post.replyRoot || post.uri)
   const ancestors = await getAncestorsAndSelfQb(db, {
     uri: post.uri,
     parentHeight: REPLY_NOTIF_DEPTH,
@@ -200,6 +258,7 @@ const insertFn = async (
     embeds,
     ancestors,
     descendents,
+    threadgate,
   }
 }
 
@@ -228,19 +287,22 @@ const notifsForInsert = (obj: IndexedPost) => {
       })
     }
   }
-  for (const embed of obj.embeds ?? []) {
-    if ('embedUri' in embed) {
-      const embedUri = new AtUri(embed.embedUri)
-      if (embedUri.collection === lex.ids.AppBskyFeedPost) {
-        maybeNotify({
-          did: embedUri.host,
-          reason: 'quote',
-          reasonSubject: embedUri.toString(),
-          author: obj.post.creator,
-          recordUri: obj.post.uri,
-          recordCid: obj.post.cid,
-          sortAt: obj.post.sortAt,
-        })
+
+  if (!obj.post.violatesEmbeddingRules) {
+    for (const embed of obj.embeds ?? []) {
+      if ('embedUri' in embed) {
+        const embedUri = new AtUri(embed.embedUri)
+        if (embedUri.collection === lex.ids.AppBskyFeedPost) {
+          maybeNotify({
+            did: embedUri.host,
+            reason: 'quote',
+            reasonSubject: embedUri.toString(),
+            author: obj.post.creator,
+            recordUri: obj.post.uri,
+            recordCid: obj.post.cid,
+            sortAt: obj.post.sortAt,
+          })
+        }
       }
     }
   }
@@ -250,6 +312,8 @@ const notifsForInsert = (obj: IndexedPost) => {
     return notifs
   }
 
+  const threadgateHiddenReplies = obj.threadgate?.hiddenReplies || []
+
   // reply notifications
 
   for (const ancestor of obj.ancestors ?? []) {
@@ -265,6 +329,8 @@ const notifsForInsert = (obj: IndexedPost) => {
         recordCid: obj.post.cid,
         sortAt: obj.post.sortAt,
       })
+      // found hidden reply, don't notify any higher ancestors
+      if (threadgateHiddenReplies.includes(ancestorUri.toString())) break
     }
   }
 
@@ -304,6 +370,7 @@ const deleteFn = async (
       .executeTakeFirst(),
     db.deleteFrom('feed_item').where('postUri', '=', uriStr).executeTakeFirst(),
   ])
+  await db.deleteFrom('quote').where('subject', '=', uriStr).execute()
   const deletedEmbeds: (
     | PostEmbedImage[]
     | PostEmbedExternal
@@ -333,7 +400,27 @@ const deleteFn = async (
     deletedEmbeds.push(deletedExternals)
   }
   if (deletedPosts) {
+    const embedUri = new AtUri(deletedPosts.embedUri)
     deletedEmbeds.push(deletedPosts)
+
+    if (embedUri.collection === lex.ids.AppBskyFeedPost) {
+      await db.deleteFrom('quote').where('uri', '=', uriStr).execute()
+      await db
+        .insertInto('post_agg')
+        .values({
+          uri: deletedPosts.embedUri,
+          quoteCount: db
+            .selectFrom('quote')
+            .where('quote.subjectCid', '=', deletedPosts.embedCid.toString())
+            .select(countAll.as('count')),
+        })
+        .onConflict((oc) =>
+          oc
+            .column('uri')
+            .doUpdateSet({ quoteCount: excluded(db, 'quoteCount') }),
+        )
+        .execute()
+    }
   }
   return deleted
     ? {
@@ -434,7 +521,7 @@ async function validateReply(
   const violatesThreadGate = await checkViolatesThreadGate(
     db,
     creator,
-    new AtUri(reply.root.uri).hostname,
+    uriToDid(reply.root.uri),
     replyRefs.root?.record ?? null,
     replyRefs.gate?.record ?? null,
   )
@@ -444,10 +531,58 @@ async function validateReply(
   }
 }
 
+async function getThreadgateRecord(db: DatabaseSchema, postUri: string) {
+  const threadgateRecordUri = postUriToThreadgateUri(postUri)
+  const results = await db
+    .selectFrom('record')
+    .where('record.uri', '=', threadgateRecordUri)
+    .selectAll()
+    .execute()
+  const threadgateRecord = results.find(
+    (ref) => ref.uri === threadgateRecordUri,
+  )
+  if (threadgateRecord) {
+    return jsonStringToLex(threadgateRecord.json) as GateRecord
+  }
+}
+
+async function validatePostEmbed(
+  db: DatabaseSchema,
+  embedUri: string,
+  parentUri: string,
+) {
+  const postgateRecordUri = postUriToPostgateUri(embedUri)
+  const postgateRecord = await db
+    .selectFrom('record')
+    .where('record.uri', '=', postgateRecordUri)
+    .selectAll()
+    .executeTakeFirst()
+  if (!postgateRecord) {
+    return {
+      violatesEmbeddingRules: false,
+    }
+  }
+  const {
+    embeddingRules: { canEmbed },
+  } = parsePostgate({
+    gate: jsonStringToLex(postgateRecord.json) as PostgateRecord,
+    viewerDid: uriToDid(parentUri),
+    authorDid: uriToDid(embedUri),
+  })
+  if (canEmbed) {
+    return {
+      violatesEmbeddingRules: false,
+    }
+  }
+  return {
+    violatesEmbeddingRules: true,
+  }
+}
+
 async function getReplyRefs(db: DatabaseSchema, reply: ReplyRef) {
   const replyRoot = reply.root.uri
   const replyParent = reply.parent.uri
-  const replyGate = postToThreadgateUri(replyRoot)
+  const replyGate = postUriToThreadgateUri(replyRoot)
   const results = await db
     .selectFrom('record')
     .where('record.uri', 'in', [replyRoot, replyGate, replyParent])

package/src/data-plane/server/indexing/plugins/thread-gate.ts

@@ -37,6 +37,11 @@ const insertFn = async (
     .onConflict((oc) => oc.doNothing())
     .returningAll()
     .executeTakeFirst()
+  await db
+    .updateTable('post')
+    .where('uri', '=', postUri.toString())
+    .set({ hasThreadGate: true })
+    .executeTakeFirst()
   return inserted || null
 }
 
@@ -66,6 +71,13 @@ const deleteFn = async (
     .where('uri', '=', uri.toString())
     .returningAll()
     .executeTakeFirst()
+  if (deleted) {
+    await db
+      .updateTable('post')
+      .where('uri', '=', deleted.postUri)
+      .set({ hasThreadGate: false })
+      .executeTakeFirst()
+  }
   return deleted || null
 }
 

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

@@ -15,6 +15,7 @@ import mutes from './mutes'
 import notifs from './notifs'
 import posts from './posts'
 import profile from './profile'
+import quotes from './quotes'
 import records from './records'
 import relationships from './relationships'
 import reposts from './reposts'
@@ -42,6 +43,7 @@ export default (db: Database, idResolver: IdResolver) =>
       ...notifs(db),
       ...posts(db),
       ...profile(db),
+      ...quotes(db),
       ...records(db),
       ...relationships(db),
       ...reposts(db),

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

@@ -8,7 +8,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   async getInteractionCounts(req) {
     const uris = req.refs.map((ref) => ref.uri)
     if (uris.length === 0) {
-      return { likes: [], replies: [], reposts: [] }
+      return { likes: [], replies: [], reposts: [], quotes: [] }
     }
     const res = await db.db
       .selectFrom('post_agg')
@@ -20,6 +20,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       likes: uris.map((uri) => byUri[uri]?.likeCount ?? 0),
       replies: uris.map((uri) => byUri[uri]?.replyCount ?? 0),
       reposts: uris.map((uri) => byUri[uri]?.repostCount ?? 0),
+      quotes: uris.map((uri) => byUri[uri]?.quoteCount ?? 0),
     }
   },
   async getCountsForUsers(req) {

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

@@ -0,0 +1,32 @@
+import { ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../../../proto/bsky_connect'
+import { Database } from '../db'
+import { paginate, TimeCidKeyset } from '../db/pagination'
+
+export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
+  async getQuotesBySubject(req) {
+    const { subject, cursor, limit } = req
+    const { ref } = db.db.dynamic
+
+    if (!subject?.uri) return { uris: [] }
+
+    let builder = db.db
+      .selectFrom('quote')
+      .where('quote.subject', '=', subject.uri)
+      .select(['quote.uri', 'quote.cid', 'quote.sortAt'])
+
+    const keyset = new TimeCidKeyset(ref('quote.sortAt'), ref('quote.cid'))
+    builder = paginate(builder, {
+      limit,
+      cursor,
+      keyset,
+    })
+
+    const quotes = await builder.execute()
+
+    return {
+      refs: quotes.map((q) => ({ uri: q.uri, cid: q.cid })),
+      cursor: keyset.packFromResult(quotes),
+    }
+  },
+})

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

@@ -20,6 +20,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   getProfileRecords: getRecords(db, ids.AppBskyActorProfile),
   getRepostRecords: getRecords(db, ids.AppBskyFeedRepost),
   getThreadGateRecords: getRecords(db, ids.AppBskyFeedThreadgate),
+  getPostGateRecords: getRecords(db, ids.AppBskyFeedPostgate),
   getLabelerRecords: getRecords(db, ids.AppBskyLabelerService),
   getActorChatDeclarationRecords: getRecords(db, ids.ChatBskyActorDeclaration),
   getStarterPackRecords: getRecords(db, ids.AppBskyGraphStarterpack),
@@ -74,7 +75,13 @@ export const getPostRecords = (db: Database) => {
         ? await db.db
             .selectFrom('post')
             .where('uri', 'in', req.uris)
-            .select(['uri', 'violatesThreadGate'])
+            .select([
+              'uri',
+              'violatesThreadGate',
+              'violatesEmbeddingRules',
+              'hasThreadGate',
+              'hasPostGate',
+            ])
             .execute()
         : [],
     ])
@@ -82,6 +89,9 @@ export const getPostRecords = (db: Database) => {
     const meta = req.uris.map((uri) => {
       return new PostRecordMeta({
         violatesThreadGate: !!byKey[uri]?.violatesThreadGate,
+        violatesEmbeddingRules: !!byKey[uri]?.violatesEmbeddingRules,
+        hasThreadGate: !!byKey[uri]?.hasThreadGate,
+        hasPostGate: !!byKey[uri]?.hasPostGate,
       })
     })
     return { records, meta }

package/src/data-plane/server/util.ts

@@ -1,6 +1,4 @@
 import { sql } from 'kysely'
-import { AtUri } from '@atproto/syntax'
-import { ids } from '../../lexicon/lexicons'
 import {
   Record as PostRecord,
   ReplyRef,
@@ -144,9 +142,3 @@ export const violatesThreadGate = async (
 
   return true
 }
-
-export const postToThreadgateUri = (postUri: string) => {
-  const gateUri = new AtUri(postUri)
-  gateUri.collection = ids.AppBskyFeedThreadgate
-  return gateUri.toString()
-}

package/src/hydration/feed.ts

@@ -4,6 +4,7 @@ import { Record as LikeRecord } from '../lexicon/types/app/bsky/feed/like'
 import { Record as RepostRecord } from '../lexicon/types/app/bsky/feed/repost'
 import { Record as FeedGenRecord } from '../lexicon/types/app/bsky/feed/generator'
 import { Record as ThreadgateRecord } from '../lexicon/types/app/bsky/feed/threadgate'
+import { Record as PostgateRecord } from '../lexicon/types/app/bsky/feed/postgate'
 import {
   HydrationMap,
   ItemRef,
@@ -12,11 +13,15 @@ import {
   parseString,
   split,
 } from './util'
-import { AtUri } from '@atproto/syntax'
-import { ids } from '../lexicon/lexicons'
 import { dedupeStrs } from '@atproto/common'
+import { postUriToThreadgateUri, postUriToPostgateUri } from '../util/uris'
 
-export type Post = RecordInfo<PostRecord> & { violatesThreadGate: boolean }
+export type Post = RecordInfo<PostRecord> & {
+  violatesThreadGate: boolean
+  violatesEmbeddingRules: boolean
+  hasThreadGate: boolean
+  hasPostGate: boolean
+}
 export type Posts = HydrationMap<Post>
 
 export type PostViewerState = {
@@ -31,6 +36,7 @@ export type PostAgg = {
   likes: number
   replies: number
   reposts: number
+  quotes: number
 }
 
 export type PostAggs = HydrationMap<PostAgg>
@@ -58,6 +64,8 @@ export type FeedGenViewerStates = HydrationMap<FeedGenViewerState>
 
 export type Threadgate = RecordInfo<ThreadgateRecord>
 export type Threadgates = HydrationMap<Threadgate>
+export type Postgate = RecordInfo<PostgateRecord>
+export type Postgates = HydrationMap<Postgate>
 
 export type ThreadRef = ItemRef & { threadRoot: string }
 
@@ -83,7 +91,21 @@ export class FeedHydrator {
     return need.reduce((acc, uri, i) => {
       const record = parseRecord<PostRecord>(res.records[i], includeTakedowns)
       const violatesThreadGate = res.meta[i].violatesThreadGate
-      return acc.set(uri, record ? { ...record, violatesThreadGate } : null)
+      const violatesEmbeddingRules = res.meta[i].violatesEmbeddingRules
+      const hasThreadGate = res.meta[i].hasThreadGate
+      const hasPostGate = res.meta[i].hasPostGate
+      return acc.set(
+        uri,
+        record
+          ? {
+              ...record,
+              violatesThreadGate,
+              violatesEmbeddingRules,
+              hasThreadGate,
+              hasPostGate,
+            }
+          : null,
+      )
     }, base)
   }
 
@@ -135,6 +157,7 @@ export class FeedHydrator {
         likes: counts.likes[i] ?? 0,
         reposts: counts.reposts[i] ?? 0,
         replies: counts.replies[i] ?? 0,
+        quotes: counts.quotes[i] ?? 0,
       })
     }, new HydrationMap<PostAgg>())
   }
@@ -185,14 +208,14 @@ export class FeedHydrator {
     includeTakedowns = false,
   ): Promise<Threadgates> {
     if (!postUris.length) return new HydrationMap<Threadgate>()
-    const uris = postUris.map((uri) => {
-      const parsed = new AtUri(uri)
-      return AtUri.make(
-        parsed.hostname,
-        ids.AppBskyFeedThreadgate,
-        parsed.rkey,
-      ).toString()
-    })
+    const uris = postUris.map(postUriToThreadgateUri)
+    return this.getThreadgateRecords(uris, includeTakedowns)
+  }
+
+  async getThreadgateRecords(
+    uris: string[],
+    includeTakedowns = false,
+  ): Promise<Threadgates> {
     const res = await this.dataplane.getThreadGateRecords({ uris })
     return uris.reduce((acc, uri, i) => {
       const record = parseRecord<ThreadgateRecord>(
@@ -203,6 +226,29 @@ export class FeedHydrator {
     }, new HydrationMap<Threadgate>())
   }
 
+  async getPostgatesForPosts(
+    postUris: string[],
+    includeTakedowns = false,
+  ): Promise<Postgates> {
+    if (!postUris.length) return new HydrationMap<Postgate>()
+    const uris = postUris.map(postUriToPostgateUri)
+    return this.getPostgateRecords(uris, includeTakedowns)
+  }
+
+  async getPostgateRecords(
+    uris: string[],
+    includeTakedowns = false,
+  ): Promise<Postgates> {
+    const res = await this.dataplane.getPostGateRecords({ uris })
+    return uris.reduce((acc, uri, i) => {
+      const record = parseRecord<PostgateRecord>(
+        res.records[i],
+        includeTakedowns,
+      )
+      return acc.set(uri, record ?? null)
+    }, new HydrationMap<Postgate>())
+  }
+
   async getLikes(uris: string[], includeTakedowns = false): Promise<Likes> {
     if (!uris.length) return new HydrationMap<Like>()
     const res = await this.dataplane.getLikeRecords({ uris })