@atproto/bsky 0.0.251 → 0.0.254

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

@@ -1,174 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { keyBy } from '@atproto/common'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import { valuesList } from '../db/util.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getRelationships(req) {
-    const { actorDid, targetDids } = req
-    if (targetDids.length === 0) {
-      return { relationships: [] }
-    }
-    const { ref } = db.db.dynamic
-    const res = await db.db
-      .selectFrom('actor')
-      .where('did', 'in', targetDids)
-      .select([
-        'actor.did',
-        db.db
-          .selectFrom('mute')
-          .where('mute.mutedByDid', '=', actorDid)
-          .whereRef('mute.subjectDid', '=', ref('actor.did'))
-          .select(sql<true>`${true}`.as('val'))
-          .as('muted'),
-        db.db
-          .selectFrom('list_item')
-          .innerJoin('list_mute', 'list_mute.listUri', 'list_item.listUri')
-          .where('list_mute.mutedByDid', '=', actorDid)
-          .whereRef('list_item.subjectDid', '=', ref('actor.did'))
-          .select('list_item.listUri')
-          .as('mutedByList'),
-        db.db
-          .selectFrom('actor_block')
-          .where('actor_block.creator', '=', actorDid)
-          .whereRef('actor_block.subjectDid', '=', ref('actor.did'))
-          .select('uri')
-          .as('blocking'),
-        db.db
-          .selectFrom('actor_block')
-          .where('actor_block.subjectDid', '=', actorDid)
-          .whereRef('actor_block.creator', '=', ref('actor.did'))
-          .select('uri')
-          .as('blockedBy'),
-        db.db
-          .selectFrom('list_item')
-          .innerJoin('list_block', 'list_block.subjectUri', 'list_item.listUri')
-          .where('list_block.creator', '=', actorDid)
-          .whereRef('list_item.subjectDid', '=', ref('actor.did'))
-          .select('list_item.listUri')
-          .as('blockingByList'),
-        db.db
-          .selectFrom('list_item')
-          .innerJoin('list_block', 'list_block.subjectUri', 'list_item.listUri')
-          .where('list_item.subjectDid', '=', actorDid)
-          .whereRef('list_block.creator', '=', ref('actor.did'))
-          .select('list_item.listUri')
-          .as('blockedByList'),
-        db.db
-          .selectFrom('follow')
-          .where('follow.creator', '=', actorDid)
-          .whereRef('follow.subjectDid', '=', ref('actor.did'))
-          .select('uri')
-          .as('following'),
-        db.db
-          .selectFrom('follow')
-          .where('follow.subjectDid', '=', actorDid)
-          .whereRef('follow.creator', '=', ref('actor.did'))
-          .select('uri')
-          .as('followedBy'),
-      ])
-      .execute()
-    const byDid = keyBy(res, 'did')
-    const relationships = targetDids.map((did) => {
-      const row = byDid.get(did)
-      return {
-        muted: row?.muted ?? false,
-        mutedByList: row?.mutedByList ?? '',
-        blockedBy: row?.blockedBy ?? '',
-        blocking: row?.blocking ?? '',
-        blockedByList: row?.blockedByList ?? '',
-        blockingByList: row?.blockingByList ?? '',
-        following: row?.following ?? '',
-        followedBy: row?.followedBy ?? '',
-      }
-    })
-    return { relationships }
-  },
-
-  async getBlockExistence(req) {
-    const { pairs } = req
-    if (pairs.length === 0) {
-      return { exists: [], blocks: [] }
-    }
-    const { ref } = db.db.dynamic
-    const sourceRef = ref('pair.source')
-    const targetRef = ref('pair.target')
-    const values = valuesList<{ source: string; target: string }>(
-      pairs.map((p) => sql`${p.a}, ${p.b}`),
-    )
-    const res = await db.db
-      .selectFrom(values.as<'pair'>(sql`pair (source, target)`))
-      .select([
-        sql<string>`${sourceRef}`.as('source'),
-        sql<string>`${targetRef}`.as('target'),
-        (eb) =>
-          eb
-            .selectFrom('actor_block')
-            .whereRef('actor_block.creator', '=', sourceRef)
-            .whereRef('actor_block.subjectDid', '=', targetRef)
-            .select('uri')
-            .as('blocking'),
-        (eb) =>
-          eb
-            .selectFrom('actor_block')
-            .whereRef('actor_block.creator', '=', targetRef)
-            .whereRef('actor_block.subjectDid', '=', sourceRef)
-            .select('uri')
-            .as('blockedBy'),
-        (eb) =>
-          eb
-            .selectFrom('list_item')
-            .innerJoin(
-              'list_block',
-              'list_block.subjectUri',
-              'list_item.listUri',
-            )
-            .whereRef('list_block.creator', '=', sourceRef)
-            .whereRef('list_item.subjectDid', '=', targetRef)
-            .select('list_item.listUri')
-            .as('blockingByList'),
-        (eb) =>
-          eb
-            .selectFrom('list_item')
-            .innerJoin(
-              'list_block',
-              'list_block.subjectUri',
-              'list_item.listUri',
-            )
-            .whereRef('list_block.creator', '=', targetRef)
-            .whereRef('list_item.subjectDid', '=', sourceRef)
-            .select('list_item.listUri')
-            .as('blockedByList'),
-      ])
-      .execute()
-    const getKey = (a, b) => [a, b].sort().join(',')
-    const lookup = res.reduce((acc, cur) => {
-      const key = getKey(cur.source, cur.target)
-      return acc.set(key, cur)
-    }, new Map<string, (typeof res)[0]>())
-    return {
-      exists: pairs.map((pair) => {
-        const item = lookup.get(getKey(pair.a, pair.b))
-        if (!item) return false
-        return !!(
-          item.blocking ||
-          item.blockedBy ||
-          item.blockingByList ||
-          item.blockedByList
-        )
-      }),
-      blocks: pairs.map((pair) => {
-        const item = lookup.get(getKey(pair.a, pair.b))
-        if (!item) return {}
-        return {
-          blockedBy: item.blockedBy || undefined,
-          blocking: item.blocking || undefined,
-          blockedByList: item.blockedByList || undefined,
-          blockingByList: item.blockingByList || undefined,
-        }
-      }),
-    }
-  },
-})

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

@@ -1,76 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { keyBy } from '@atproto/common'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import { TimeCidKeyset, paginate } from '../db/pagination.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getRepostsBySubject(req) {
-    const { subject, cursor, limit } = req
-    const { ref } = db.db.dynamic
-
-    let builder = db.db
-      .selectFrom('repost')
-      .where('repost.subject', '=', subject?.uri ?? '')
-      .selectAll('repost')
-
-    const keyset = new TimeCidKeyset(ref('repost.sortAt'), ref('repost.cid'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-
-    const reposts = await builder.execute()
-
-    return {
-      uris: reposts.map((l) => l.uri),
-      cursor: keyset.packFromResult(reposts),
-    }
-  },
-
-  async getRepostsByActorAndSubjects(req) {
-    const { actorDid, refs } = req
-    if (refs.length === 0) {
-      return { uris: [] }
-    }
-    const res = await db.db
-      .selectFrom('repost')
-      .where('creator', '=', actorDid)
-      .where(
-        'subject',
-        'in',
-        refs.map(({ uri }) => uri),
-      )
-      .selectAll()
-      .execute()
-    const bySubject = keyBy(res, 'subject')
-    const uris = refs.map(({ uri }) => bySubject.get(uri)?.uri ?? '')
-    return { uris }
-  },
-
-  async getActorReposts(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-
-    let builder = db.db
-      .selectFrom('repost')
-      .where('repost.creator', '=', actorDid)
-      .selectAll()
-
-    const keyset = new TimeCidKeyset(ref('repost.sortAt'), ref('repost.cid'))
-
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-
-    const reposts = await builder.execute()
-
-    return {
-      uris: reposts.map((l) => l.uri),
-      cursor: keyset.packFromResult(reposts),
-    }
-  },
-})

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

@@ -1,181 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import {
-  IndexedAtDidKeyset,
-  TimeCidKeyset,
-  paginate,
-} from '../db/pagination.js'
-import { parsePostSearchQuery } from '../util.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => {
-  const searchActorsImpl = async (req: {
-    term: string
-    limit: number
-    cursor?: string
-  }) => {
-    const { term, limit, cursor } = req
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('actor')
-      .where('actor.handle', 'like', `%${cleanQuery(term)}%`)
-      .selectAll()
-
-    const keyset = new IndexedAtDidKeyset(
-      ref('actor.indexedAt'),
-      ref('actor.did'),
-    )
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const res = await builder.execute()
-
-    return {
-      dids: res.map((row) => row.did),
-      cursor: keyset.packFromResult(res),
-    }
-  }
-
-  const searchPostsImpl = async (req: {
-    term: string
-    limit: number
-    cursor?: string
-  }) => {
-    const { term, limit, cursor } = req
-    const { q, author } = parsePostSearchQuery(term)
-
-    let authorDid = author
-    if (author && !author?.startsWith('did:')) {
-      const res = await db.db
-        .selectFrom('actor')
-        .where('handle', '=', author)
-        .selectAll()
-        .executeTakeFirst()
-      authorDid = res?.did
-    }
-
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('post')
-      .where('post.text', 'like', `%${q}%`)
-      .selectAll()
-
-    if (authorDid) {
-      builder = builder.where('post.creator', '=', authorDid)
-    }
-
-    const keyset = new TimeCidKeyset(ref('post.sortAt'), ref('post.cid'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const res = await builder.execute()
-    return {
-      uris: res.map((row) => row.uri),
-      cursor: keyset.packFromResult(res),
-    }
-  }
-
-  const searchStarterPacksImpl = async (req: {
-    term: string
-    limit: number
-    cursor?: string
-  }) => {
-    const { term, limit, cursor } = req
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('starter_pack')
-      .where('starter_pack.name', 'ilike', `%${term}%`)
-      .selectAll()
-
-    const keyset = new TimeCidKeyset(
-      ref('starter_pack.sortAt'),
-      ref('starter_pack.cid'),
-    )
-
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const res = await builder.execute()
-
-    return {
-      uris: res.map((row) => row.uri),
-      cursor: keyset.packFromResult(res),
-    }
-  }
-
-  return {
-    // @TODO actor search endpoints still fall back to search service
-    searchActors: searchActorsImpl,
-
-    // @TODO post search endpoint still falls back to search service
-    searchPosts: searchPostsImpl,
-
-    searchStarterPacks: searchStarterPacksImpl,
-
-    // V2 endpoints reuse the V1 SQL for dev env and reshape the response.
-    async searchActorsV2(req) {
-      const { dids, cursor } = await searchActorsImpl({
-        term: req.params?.query ?? '',
-        limit: req.params?.limit ?? 25,
-        cursor: req.params?.cursor,
-      })
-      return {
-        actors: dids.map((did) => ({ did, score: 0 })),
-        pageInfo: { cursor: cursor ?? '', hitsTotal: 0n },
-      }
-    },
-
-    async searchActorsTypeahead(req) {
-      const { dids } = await searchActorsImpl({
-        term: req.params?.query ?? '',
-        limit: req.params?.limit || 10,
-      })
-      return {
-        actors: dids.map((did) => ({ did, score: 0 })),
-      }
-    },
-
-    async searchPostsV2(req) {
-      const author = req.filters?.authors?.[0]
-      const baseQuery = req.params?.query ?? ''
-      const term = author ? `${baseQuery} from:${author}` : baseQuery
-      const { uris, cursor } = await searchPostsImpl({
-        term,
-        limit: req.params?.limit ?? 25,
-        cursor: req.params?.cursor,
-      })
-      return {
-        posts: uris.map((uri) => ({ uri, score: 0 })),
-        pageInfo: { cursor: cursor ?? '', hitsTotal: 0n },
-        detectedQueryLanguages: [],
-      }
-    },
-
-    async searchStarterPacksV2(req) {
-      const { uris, cursor } = await searchStarterPacksImpl({
-        term: req.params?.query ?? '',
-        limit: req.params?.limit ?? 25,
-        cursor: req.params?.cursor,
-      })
-      return {
-        starterPacks: uris.map((uri) => ({ uri, score: 0 })),
-        pageInfo: { cursor: cursor ?? '', hitsTotal: 0n },
-      }
-    },
-  }
-}
-
-// Remove leading @ in case a handle is input that way
-const cleanQuery = (query: string) => query.trim().replace(/^@/g, '')

package/src/data-plane/server/routes/site-standard.ts

@@ -1,12 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-
-export default (_db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getSiteStandardRecordsByURI() {
-    return { documents: [], publications: [] }
-  },
-  async getSiteStandardRecordsByRef() {
-    return { documents: [], publications: [] }
-  },
-})

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

@@ -1,43 +0,0 @@
-import { gzipSync } from 'node:zlib'
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
-import { Service } from '../../../proto/bsky_connect.js'
-import { GetSitemapPageRequest } from '../../../proto/bsky_pb.js'
-
-const MOCK_SITEMAP_INDEX = `<?xml version="1.0" encoding="UTF-8"?>
-<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <sitemap>
-    <loc>https://bsky.app/sitemap/users/2025-01-01/1.xml.gz</loc>
-  </sitemap>
-</sitemapindex>`
-
-const MOCK_SITEMAP_PAGE = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-  <url>
-    <loc>https://bsky.app/profile/test.bsky.social</loc>
-  </url>
-</urlset>`
-
-export default (): Partial<ServiceImpl<typeof Service>> => ({
-  async getSitemapIndex() {
-    return {
-      sitemap: gzipSync(Buffer.from(MOCK_SITEMAP_INDEX)),
-    }
-  },
-  async getSitemapPage(req: GetSitemapPageRequest) {
-    const date = req.date?.toDate()
-    const isExpectedDate =
-      date &&
-      date.getFullYear() === 2025 &&
-      date.getMonth() === 0 &&
-      date.getDate() === 1
-    const isExpectedBucket = req.bucket === 1
-
-    if (!isExpectedDate || !isExpectedBucket) {
-      throw new ConnectError('Sitemap page not found', Code.NotFound)
-    }
-
-    return {
-      sitemap: gzipSync(Buffer.from(MOCK_SITEMAP_PAGE)),
-    }
-  },
-})

package/src/data-plane/server/routes/starter-packs.ts

@@ -1,32 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import { TimeCidKeyset, paginate } from '../db/pagination.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getActorStarterPacks(req) {
-    const { actorDid, limit, cursor } = req
-
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('starter_pack')
-      .selectAll()
-      .where('creator', '=', actorDid)
-
-    const keyset = new TimeCidKeyset(
-      ref('starter_pack.sortAt'),
-      ref('starter_pack.cid'),
-    )
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-    const starterPacks = await builder.execute()
-
-    return {
-      uris: starterPacks.map((sp) => sp.uri),
-      cursor: keyset.packFromResult(starterPacks),
-    }
-  },
-})

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

@@ -1,175 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getFollowSuggestions(req) {
-    const { actorDid, relativeToDid, cursor, limit } = req
-    if (relativeToDid) {
-      return getFollowSuggestionsRelativeTo(db, {
-        actorDid,
-        relativeToDid,
-        cursor: cursor || undefined,
-        limit: limit || undefined,
-      })
-    } else {
-      return getFollowSuggestionsGlobal(db, {
-        actorDid,
-        cursor: cursor || undefined,
-        limit: limit || undefined,
-      })
-    }
-  },
-
-  async getSuggestedEntities() {
-    const entities = await db.db
-      .selectFrom('tagged_suggestion')
-      .selectAll()
-      .execute()
-    return {
-      entities,
-    }
-  },
-})
-
-const getFollowSuggestionsGlobal = async (
-  db: Database,
-  input: { actorDid: string; cursor?: string; limit?: number },
-) => {
-  const alreadyIncluded = parseCursor(input.cursor)
-  const suggestions = await db.db
-    .selectFrom('suggested_follow')
-    .innerJoin('actor', 'actor.did', 'suggested_follow.did')
-    .$if(alreadyIncluded.length > 0, (qb) =>
-      qb.where('suggested_follow.order', 'not in', alreadyIncluded),
-    )
-    .selectAll()
-    .orderBy('suggested_follow.order', 'asc')
-    .execute()
-
-  // always include first two
-  const firstTwo = suggestions.filter(
-    (row) => row.order === 1 || row.order === 2,
-  )
-  const rest = suggestions.filter((row) => row.order !== 1 && row.order !== 2)
-  const limited = firstTwo.concat(shuffle(rest)).slice(0, input.limit)
-
-  // if the result set ends up getting larger, consider using a seed included in the cursor for the randomized shuffle
-  const cursor =
-    limited.length > 0
-      ? limited
-          .map((row) => row.order.toString())
-          .concat(alreadyIncluded.map((id) => id.toString()))
-          .join(':')
-      : undefined
-
-  return {
-    dids: limited.map((s) => s.did),
-    cursor,
-  }
-}
-
-const getFollowSuggestionsRelativeTo = async (
-  db: Database,
-  input: {
-    actorDid: string
-    relativeToDid: string
-    cursor?: string
-    limit?: number
-  },
-) => {
-  if (input.cursor) return { dids: [] }
-  const limit = input.limit ? Math.min(10, input.limit) : 10
-  const actorsViewerFollows = db.db
-    .selectFrom('follow')
-    .where('creator', '=', input.actorDid)
-    .select('subjectDid')
-  const mostLikedAccounts = await db.db
-    .selectFrom(
-      db.db
-        .selectFrom('like')
-        .where('creator', '=', input.relativeToDid)
-        .select(sql`split_part(subject, '/', 3)`.as('subjectDid'))
-        .orderBy('sortAt', 'desc')
-        .limit(1000) // limit to 1000
-        .as('likes'),
-    )
-    .select('likes.subjectDid as did')
-    .select((qb) => qb.fn.count('likes.subjectDid').as('count'))
-    .where('likes.subjectDid', 'not in', actorsViewerFollows)
-    .where('likes.subjectDid', 'not in', [input.actorDid, input.relativeToDid])
-    .groupBy('likes.subjectDid')
-    .orderBy('count', 'desc')
-    .limit(limit)
-    .execute()
-  const resultDids = mostLikedAccounts.map((a) => ({ did: a.did })) as {
-    did: string
-  }[]
-
-  if (resultDids.length < limit) {
-    // backfill with popular accounts followed by actor
-    const mostPopularAccountsActorFollows = await db.db
-      .selectFrom('follow')
-      .innerJoin('profile_agg', 'follow.subjectDid', 'profile_agg.did')
-      .select('follow.subjectDid as did')
-      .where('follow.creator', '=', input.actorDid)
-      .where('follow.subjectDid', '!=', input.relativeToDid)
-      .where('follow.subjectDid', 'not in', actorsViewerFollows)
-      .$if(resultDids.length > 0, (qb) =>
-        qb.where(
-          'subjectDid',
-          'not in',
-          resultDids.map((a) => a.did),
-        ),
-      )
-      .orderBy('profile_agg.followersCount', 'desc')
-      .limit(limit)
-      .execute()
-
-    resultDids.push(...mostPopularAccountsActorFollows)
-  }
-
-  if (resultDids.length < limit) {
-    // backfill with suggested_follow table
-    const additional = await db.db
-      .selectFrom('suggested_follow')
-      .where(
-        'did',
-        'not in',
-        // exclude any we already have
-        resultDids
-          .map((a) => a.did)
-          .concat([input.actorDid, input.relativeToDid]),
-      )
-      // and aren't already followed by viewer
-      .where('did', 'not in', actorsViewerFollows)
-      .selectAll()
-      .execute()
-
-    resultDids.push(...additional)
-  }
-
-  return { dids: resultDids.map((x) => x.did) }
-}
-
-const parseCursor = (cursor?: string): number[] => {
-  if (!cursor) {
-    return []
-  }
-  try {
-    return cursor
-      .split(':')
-      .map((id) => parseInt(id, 10))
-      .filter((id) => !isNaN(id))
-  } catch {
-    return []
-  }
-}
-
-const shuffle = <T>(arr: T[]): T[] => {
-  return arr
-    .map((value) => ({ value, sort: Math.random() }))
-    .sort((a, b) => a.sort - b.sort)
-    .map(({ value }) => value)
-}