@atproto/bsky 0.0.250 → 0.0.253

package/src/data-plane/server/routes/feed-gens.ts

@@ -1,89 +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 getActorFeeds(req) {
-    const { actorDid, limit, cursor } = req
-
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('feed_generator')
-      .selectAll()
-      .where('feed_generator.creator', '=', actorDid)
-
-    const keyset = new TimeCidKeyset(
-      ref('feed_generator.createdAt'),
-      ref('feed_generator.cid'),
-    )
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-    const feeds = await builder.execute()
-
-    return {
-      uris: feeds.map((f) => f.uri),
-      cursor: keyset.packFromResult(feeds),
-    }
-  },
-
-  async getSuggestedFeeds(req) {
-    const feeds = await db.db
-      .selectFrom('suggested_feed')
-      .orderBy('suggested_feed.order', 'asc')
-      .$if(!!req.cursor, (q) => q.where('order', '>', parseInt(req.cursor, 10)))
-      .limit(req.limit || 50)
-      .selectAll()
-      .execute()
-    return {
-      uris: feeds.map((f) => f.uri),
-      cursor: feeds.at(-1)?.order.toString(),
-    }
-  },
-
-  async searchFeedGenerators(req) {
-    return searchFeedGeneratorsImpl(db, req.query, req.limit)
-  },
-
-  async searchFeedGeneratorsV2(req) {
-    const { uris, cursor } = await searchFeedGeneratorsImpl(
-      db,
-      req.params?.query ?? '',
-      req.params?.limit ?? 25,
-    )
-    return {
-      feedGenerators: uris.map((uri) => ({ uri, score: 0 })),
-      pageInfo: { cursor: cursor ?? '', hitsTotal: 0n },
-    }
-  },
-
-  async getFeedGeneratorStatus() {
-    throw new Error('unimplemented')
-  },
-})
-
-const searchFeedGeneratorsImpl = async (
-  db: Database,
-  query: string,
-  limit: number,
-) => {
-  const { ref } = db.db.dynamic
-  const trimmed = query.trim()
-  let builder = db.db
-    .selectFrom('feed_generator')
-    .$if(!!trimmed, (q) => q.where('displayName', 'ilike', `%${trimmed}%`))
-    .selectAll()
-  const keyset = new TimeCidKeyset(
-    ref('feed_generator.createdAt'),
-    ref('feed_generator.cid'),
-  )
-  builder = paginate(builder, { limit, keyset })
-  const feeds = await builder.execute()
-  return {
-    uris: feeds.map((f) => f.uri),
-    cursor: keyset.packFromResult(feeds),
-  }
-}

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

@@ -1,176 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { Service } from '../../../proto/bsky_connect.js'
-import { FeedType } from '../../../proto/bsky_pb.js'
-import { Database } from '../db/index.js'
-import { TimeCidKeyset, paginate } from '../db/pagination.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getAuthorFeed(req) {
-    const { actorDid, limit, cursor, feedType } = req
-    const { ref } = db.db.dynamic
-
-    // defaults to posts, reposts, and replies
-    let builder = db.db
-      .selectFrom('feed_item')
-      .innerJoin('post', 'post.uri', 'feed_item.postUri')
-      .selectAll('feed_item')
-      .where('originatorDid', '=', actorDid)
-
-    if (feedType === FeedType.POSTS_WITH_MEDIA) {
-      builder = builder
-        // only your own posts
-        .where('type', '=', 'post')
-        // only posts with media
-        .where((eb) =>
-          eb.or([
-            eb.exists(
-              eb
-                .selectFrom('post_embed_image')
-                .select('post_embed_image.postUri')
-                .whereRef('post_embed_image.postUri', '=', 'feed_item.postUri'),
-            ),
-            eb.exists(
-              eb
-                .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
-        // only your own posts
-        .where('type', '=', 'post')
-        // only posts with video
-        .where(({ eb, exists }) =>
-          exists(
-            eb
-              .selectFrom('post_embed_video')
-              .select('post_embed_video.postUri')
-              .whereRef('post_embed_video.postUri', '=', 'feed_item.postUri'),
-          ),
-        )
-    } else if (feedType === FeedType.POSTS_NO_REPLIES) {
-      builder = builder.where((eb) =>
-        eb.or([eb('post.replyParent', 'is', null), eb('type', '=', 'repost')]),
-      )
-    } else if (feedType === FeedType.POSTS_AND_AUTHOR_THREADS) {
-      builder = builder.where((eb) =>
-        eb.or([
-          eb('type', '=', 'repost'),
-          eb('post.replyParent', 'is', null),
-          eb('post.replyRoot', 'like', `at://${actorDid}/%`),
-        ]),
-      )
-    }
-
-    const keyset = new TimeCidKeyset(
-      ref('feed_item.sortAt'),
-      ref('feed_item.cid'),
-    )
-
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-
-    const feedItems = await builder.execute()
-
-    return {
-      items: feedItems.map(feedItemFromRow),
-      cursor: keyset.packFromResult(feedItems),
-    }
-  },
-
-  async getTimeline(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-
-    const keyset = new TimeCidKeyset(
-      ref('feed_item.sortAt'),
-      ref('feed_item.cid'),
-    )
-
-    let followQb = db.db
-      .selectFrom('feed_item')
-      .innerJoin('follow', 'follow.subjectDid', 'feed_item.originatorDid')
-      .where('follow.creator', '=', actorDid)
-      .selectAll('feed_item')
-
-    followQb = paginate(followQb, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    let selfQb = db.db
-      .selectFrom('feed_item')
-      .where('feed_item.originatorDid', '=', actorDid)
-      .selectAll('feed_item')
-
-    selfQb = paginate(selfQb, {
-      limit: Math.min(limit, 10),
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const [followRes, selfRes] = await Promise.all([
-      followQb.execute(),
-      selfQb.execute(),
-    ])
-
-    const feedItems = [...followRes, ...selfRes]
-      .sort((a, b) => {
-        if (a.sortAt > b.sortAt) return -1
-        if (a.sortAt < b.sortAt) return 1
-        return a.cid > b.cid ? -1 : 1
-      })
-      .slice(0, limit)
-
-    return {
-      items: feedItems.map(feedItemFromRow),
-      cursor: keyset.packFromResult(feedItems),
-    }
-  },
-
-  async getListFeed(req) {
-    const { listUri, cursor, limit } = req
-    const { ref } = db.db.dynamic
-
-    let builder = db.db
-      .selectFrom('post')
-      .selectAll('post')
-      .innerJoin('list_item', 'list_item.subjectDid', 'post.creator')
-      .where('list_item.listUri', '=', listUri)
-
-    const keyset = new TimeCidKeyset(ref('post.sortAt'), ref('post.cid'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-    const feedItems = await builder.execute()
-
-    return {
-      items: feedItems.map((item) => ({ uri: item.uri, cid: item.cid })),
-      cursor: keyset.packFromResult(feedItems),
-    }
-  },
-})
-
-// @NOTE does not support additional fields in the protos specific to author feeds
-// and timelines. at the time of writing, hydration/view implementations do not rely on them.
-const feedItemFromRow = (row: { postUri: string; uri: string }) => {
-  return {
-    uri: row.postUri,
-    repost: row.uri === row.postUri ? undefined : row.uri,
-  }
-}

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

@@ -1,141 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { keyBy } from '@atproto/common'
-import { Service } from '../../../proto/bsky_connect.js'
-import { FollowsFollowing } from '../../../proto/bsky_pb.js'
-import { Database } from '../db/index.js'
-import { TimeCidKeyset, paginate } from '../db/pagination.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getActorFollowsActors(req) {
-    const { actorDid, targetDids } = req
-    if (targetDids.length < 1) {
-      return { uris: [] }
-    }
-    const res = await db.db
-      .selectFrom('follow')
-      .where('follow.creator', '=', actorDid)
-      .where('follow.subjectDid', 'in', targetDids)
-      .selectAll()
-      .execute()
-    const bySubject = keyBy(res, 'subjectDid')
-    const uris = targetDids.map((did) => bySubject.get(did)?.uri ?? '')
-    return {
-      uris,
-    }
-  },
-  async getFollowers(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-    let followersReq = db.db
-      .selectFrom('follow')
-      .where('follow.subjectDid', '=', actorDid)
-      .innerJoin('actor as creator', 'creator.did', 'follow.creator')
-      .selectAll('creator')
-      .select([
-        'follow.uri as uri',
-        'follow.cid as cid',
-        'follow.creator as creatorDid',
-        'follow.subjectDid as subjectDid',
-        'follow.sortAt as sortAt',
-      ])
-
-    const keyset = new TimeCidKeyset(ref('follow.sortAt'), ref('follow.cid'))
-    followersReq = paginate(followersReq, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const followers = await followersReq.execute()
-    return {
-      followers: followers.map((f) => ({
-        uri: f.uri,
-        actorDid: f.creatorDid,
-        subjectDid: f.subjectDid,
-      })),
-      cursor: keyset.packFromResult(followers),
-    }
-  },
-  async getFollows(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-
-    let followsReq = db.db
-      .selectFrom('follow')
-      .where('follow.creator', '=', actorDid)
-      .innerJoin('actor as subject', 'subject.did', 'follow.subjectDid')
-      .selectAll('subject')
-      .select([
-        'follow.uri as uri',
-        'follow.cid as cid',
-        'follow.creator as creatorDid',
-        'follow.subjectDid as subjectDid',
-        'follow.sortAt as sortAt',
-      ])
-
-    const keyset = new TimeCidKeyset(ref('follow.sortAt'), ref('follow.cid'))
-    followsReq = paginate(followsReq, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const follows = await followsReq.execute()
-
-    return {
-      follows: follows.map((f) => ({
-        uri: f.uri,
-        actorDid: f.creatorDid,
-        subjectDid: f.subjectDid,
-      })),
-      cursor: keyset.packFromResult(follows),
-    }
-  },
-
-  /**
-   * Return known followers of a given actor.
-   *
-   * Example:
-   *   - Alice follows Bob
-   *   - Bob follows Dan
-   *
-   *   If Alice (the viewer) looks at Dan's profile (the subject), she should see that Bob follows Dan
-   */
-  async getFollowsFollowing(req) {
-    const { actorDid: viewerDid, targetDids: subjectDids } = req
-
-    /*
-     * 1. Get all the people the Alice is following
-     * 2. Get all the people the Dan is followed by
-     * 3. Find the intersection
-     */
-
-    const results: FollowsFollowing[] = []
-
-    for (const subjectDid of subjectDids) {
-      const followsReq = db.db
-        .selectFrom('follow')
-        .where('follow.creator', '=', viewerDid)
-        .where(
-          'follow.subjectDid',
-          'in',
-          db.db
-            .selectFrom('follow')
-            .where('follow.subjectDid', '=', subjectDid)
-            .select(['creator']),
-        )
-        .select(['subjectDid'])
-      const rows = await followsReq.execute()
-      results.push(
-        new FollowsFollowing({
-          targetDid: subjectDid,
-          dids: rows.map((r) => r.subjectDid),
-        }),
-      )
-    }
-
-    return { results }
-  },
-})

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

@@ -1,59 +0,0 @@
-import { Timestamp } from '@bufbuild/protobuf'
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
-import { DidDocument, IdResolver, getDid, getHandle } from '@atproto/identity'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-
-export default (
-  _db: Database,
-  idResolver: IdResolver,
-): Partial<ServiceImpl<typeof Service>> => ({
-  async getIdentityByDid(req) {
-    const doc = await idResolver.did.resolve(req.did)
-    if (!doc) {
-      throw new ConnectError('identity not found', Code.NotFound)
-    }
-    return getResultFromDoc(doc)
-  },
-
-  async getIdentityByHandle(req) {
-    const did = await idResolver.handle.resolve(req.handle)
-    if (!did) {
-      throw new ConnectError('identity not found', Code.NotFound)
-    }
-    const doc = await idResolver.did.resolve(did)
-    if (!doc || did !== getDid(doc)) {
-      throw new ConnectError('identity not found', Code.NotFound)
-    }
-    return getResultFromDoc(doc)
-  },
-})
-
-const getResultFromDoc = (doc: DidDocument) => {
-  const keys: Record<string, { Type: string; PublicKeyMultibase: string }> = {}
-  doc.verificationMethod?.forEach((method) => {
-    const id = method.id.split('#').at(1)
-    if (!id) return
-    keys[id] = {
-      Type: method.type,
-      PublicKeyMultibase: method.publicKeyMultibase || '',
-    }
-  })
-  const services: Record<string, { Type: string; URL: string }> = {}
-  doc.service?.forEach((service) => {
-    const id = service.id.split('#').at(1)
-    if (!id) return
-    if (typeof service.serviceEndpoint !== 'string') return
-    services[id] = {
-      Type: service.type,
-      URL: service.serviceEndpoint,
-    }
-  })
-  return {
-    did: getDid(doc),
-    handle: getHandle(doc),
-    keys: Buffer.from(JSON.stringify(keys)),
-    services: Buffer.from(JSON.stringify(services)),
-    updated: Timestamp.fromDate(new Date()),
-  }
-}

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

@@ -1,67 +0,0 @@
-import { ConnectRouter } from '@connectrpc/connect'
-import { IdResolver } from '@atproto/identity'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import activitySubscription from './activity-subscription.js'
-import blocks from './blocks.js'
-import bookmarks from './bookmarks.js'
-import drafts from './drafts.js'
-import feedGens from './feed-gens.js'
-import feeds from './feeds.js'
-import follows from './follows.js'
-import identity from './identity.js'
-import interactions from './interactions.js'
-import labels from './labels.js'
-import likes from './likes.js'
-import lists from './lists.js'
-import moderation from './moderation.js'
-import mutes from './mutes.js'
-import notifs from './notifs.js'
-import profile from './profile.js'
-import quotes from './quotes.js'
-import records from './records.js'
-import relationships from './relationships.js'
-import reposts from './reposts.js'
-import search from './search.js'
-import siteStandard from './site-standard.js'
-import sitemap from './sitemap.js'
-import starterPacks from './starter-packs.js'
-import suggestions from './suggestions.js'
-import sync from './sync.js'
-import threads from './threads.js'
-
-export default (db: Database, idResolver: IdResolver) =>
-  (router: ConnectRouter) =>
-    router.service(Service, {
-      ...activitySubscription(db),
-      ...blocks(db),
-      ...bookmarks(db),
-      ...drafts(db),
-      ...feedGens(db),
-      ...feeds(db),
-      ...follows(db),
-      ...identity(db, idResolver),
-      ...interactions(db),
-      ...labels(db),
-      ...likes(db),
-      ...lists(db),
-      ...moderation(db),
-      ...mutes(db),
-      ...notifs(db),
-      ...profile(db),
-      ...quotes(db),
-      ...records(db),
-      ...relationships(db),
-      ...reposts(db),
-      ...search(db),
-      ...sitemap(),
-      ...siteStandard(db),
-      ...suggestions(db),
-      ...sync(db),
-      ...threads(db),
-      ...starterPacks(db),
-
-      async ping() {
-        return {}
-      },
-    })

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

@@ -1,120 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { DAY, keyBy } from '@atproto/common'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import { countAll } from '../db/util.js'
-
-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: [], quotes: [] }
-    }
-    const res = await db.db
-      .selectFrom('post_agg')
-      .where('uri', 'in', uris)
-      .selectAll()
-      .execute()
-    const byUri = keyBy(res, 'uri')
-    return {
-      likes: uris.map((uri) => byUri.get(uri)?.likeCount ?? 0),
-      replies: uris.map((uri) => byUri.get(uri)?.replyCount ?? 0),
-      reposts: uris.map((uri) => byUri.get(uri)?.repostCount ?? 0),
-      quotes: uris.map((uri) => byUri.get(uri)?.quoteCount ?? 0),
-      bookmarks: uris.map((uri) => byUri.get(uri)?.bookmarkCount ?? 0),
-    }
-  },
-  async getCountsForUsers(req) {
-    if (req.dids.length === 0) {
-      return {}
-    }
-    const { ref } = db.db.dynamic
-    const res = await db.db
-      .selectFrom('profile_agg')
-      .where('did', 'in', req.dids)
-      .selectAll('profile_agg')
-      .select([
-        db.db
-          .selectFrom('feed_generator')
-          .whereRef('creator', '=', ref('profile_agg.did'))
-          .select(countAll.as('val'))
-          .as('feedGensCount'),
-        db.db
-          .selectFrom('list')
-          .whereRef('creator', '=', ref('profile_agg.did'))
-          .select(countAll.as('val'))
-          .as('listsCount'),
-        db.db
-          .selectFrom('starter_pack')
-          .whereRef('creator', '=', ref('profile_agg.did'))
-          .select(countAll.as('val'))
-          .as('starterPacksCount'),
-        db.db
-          .selectFrom('draft')
-          .whereRef('creator', '=', ref('profile_agg.did'))
-          .select(countAll.as('val'))
-          .as('draftsCount'),
-      ])
-      .execute()
-    const byDid = keyBy(res, 'did')
-    return {
-      followers: req.dids.map((uri) => byDid.get(uri)?.followersCount ?? 0),
-      following: req.dids.map((uri) => byDid.get(uri)?.followsCount ?? 0),
-      posts: req.dids.map((uri) => byDid.get(uri)?.postsCount ?? 0),
-      lists: req.dids.map((uri) => byDid.get(uri)?.listsCount ?? 0),
-      feeds: req.dids.map((uri) => byDid.get(uri)?.feedGensCount ?? 0),
-      starterPacks: req.dids.map(
-        (uri) => byDid.get(uri)?.starterPacksCount ?? 0,
-      ),
-      drafts: req.dids.map((uri) => byDid.get(uri)?.draftsCount ?? 0),
-    }
-  },
-  async getStarterPackCounts(req) {
-    const weekAgo = new Date(Date.now() - 7 * DAY)
-    const uris = req.refs.map((ref) => ref.uri)
-    if (uris.length === 0) {
-      return { joinedAllTime: [], joinedWeek: [] }
-    }
-    const countsAllTime = await db.db
-      .selectFrom('profile')
-      .where('joinedViaStarterPackUri', 'in', uris)
-      .select(['joinedViaStarterPackUri as uri', countAll.as('count')])
-      .groupBy('joinedViaStarterPackUri')
-      .execute()
-    const countsWeek = await db.db
-      .selectFrom('profile')
-      .where('joinedViaStarterPackUri', 'in', uris)
-      .where('createdAt', '>', weekAgo.toISOString())
-      .select(['joinedViaStarterPackUri as uri', countAll.as('count')])
-      .groupBy('joinedViaStarterPackUri')
-      .execute()
-    const countsWeekByUri = countsWeek.reduce((cur, item) => {
-      if (!item.uri) return cur
-      return cur.set(item.uri, item.count)
-    }, new Map<string, number>())
-    const countsAllTimeByUri = countsAllTime.reduce((cur, item) => {
-      if (!item.uri) return cur
-      return cur.set(item.uri, item.count)
-    }, new Map<string, number>())
-    return {
-      joinedWeek: uris.map((uri) => countsWeekByUri.get(uri) ?? 0),
-      joinedAllTime: uris.map((uri) => countsAllTimeByUri.get(uri) ?? 0),
-    }
-  },
-  async getListCounts(req) {
-    const uris = req.refs.map((ref) => ref.uri)
-    if (uris.length === 0) {
-      return { listItems: [] }
-    }
-    const countsListItems = await db.db
-      .selectFrom('list_item')
-      .where('listUri', 'in', uris)
-      .select(['listUri as uri', countAll.as('count')])
-      .groupBy('listUri')
-      .execute()
-    const countsByUri = keyBy(countsListItems, 'uri')
-    return {
-      listItems: uris.map((uri) => countsByUri.get(uri)?.count ?? 0),
-    }
-  },
-})