@atproto/bsky 0.0.64 → 0.0.65

package/src/api/app/bsky/graph/getStarterPacks.ts

@@ -0,0 +1,81 @@
+import { dedupeStrs, mapDefined } from '@atproto/common'
+import { Server } from '../../../../lexicon'
+import { QueryParams } from '../../../../lexicon/types/app/bsky/graph/getStarterPacks'
+import AppContext from '../../../../context'
+import { resHeaders } from '../../../util'
+import { createPipeline, noRules } from '../../../../pipeline'
+import {
+  HydrateCtx,
+  HydrationState,
+  Hydrator,
+} from '../../../../hydration/hydrator'
+import { Views } from '../../../../views'
+
+export default function (server: Server, ctx: AppContext) {
+  const getStarterPacks = createPipeline(
+    skeleton,
+    hydration,
+    noRules,
+    presentation,
+  )
+  server.app.bsky.graph.getStarterPacks({
+    auth: ctx.authVerifier.standardOptional,
+    handler: async ({ auth, params, req }) => {
+      const { viewer, includeTakedowns } = ctx.authVerifier.parseCreds(auth)
+      const labelers = ctx.reqLabelers(req)
+      const hydrateCtx = await ctx.hydrator.createContext({
+        viewer,
+        labelers,
+        includeTakedowns,
+      })
+
+      const result = await getStarterPacks({ ...params, hydrateCtx }, ctx)
+
+      return {
+        encoding: 'application/json',
+        body: result,
+        headers: resHeaders({ labelers: hydrateCtx.labelers }),
+      }
+    },
+  })
+}
+
+const skeleton = async (inputs: { params: Params }) => {
+  return { uris: inputs.params.uris }
+}
+
+const hydration = async (input: {
+  ctx: Context
+  params: Params
+  skeleton: SkeletonState
+}) => {
+  const { ctx, params, skeleton } = input
+  return ctx.hydrator.hydrateStarterPacksBasic(
+    dedupeStrs(skeleton.uris),
+    params.hydrateCtx,
+  )
+}
+
+const presentation = (input: {
+  ctx: Context
+  params: Params
+  skeleton: SkeletonState
+  hydration: HydrationState
+}) => {
+  const { ctx, skeleton, hydration } = input
+  const starterPacks = mapDefined(skeleton.uris, (did) =>
+    ctx.views.starterPackBasic(did, hydration),
+  )
+  return { starterPacks }
+}
+
+type Context = {
+  hydrator: Hydrator
+  views: Views
+}
+
+type Params = QueryParams & {
+  hydrateCtx: HydrateCtx
+}
+
+type SkeletonState = { uris: string[] }

package/src/api/index.ts

@@ -16,6 +16,7 @@ import getActorLikes from './app/bsky/feed/getActorLikes'
 import getProfile from './app/bsky/actor/getProfile'
 import getProfiles from './app/bsky/actor/getProfiles'
 import getRepostedBy from './app/bsky/feed/getRepostedBy'
+import getActorStarterPacks from './app/bsky/graph/getActorStarterPacks'
 import getBlocks from './app/bsky/graph/getBlocks'
 import getListBlocks from './app/bsky/graph/getListBlocks'
 import getFollowers from './app/bsky/graph/getFollowers'
@@ -26,6 +27,8 @@ import getLists from './app/bsky/graph/getLists'
 import getListMutes from './app/bsky/graph/getListMutes'
 import getMutes from './app/bsky/graph/getMutes'
 import getRelationships from './app/bsky/graph/getRelationships'
+import getStarterPack from './app/bsky/graph/getStarterPack'
+import getStarterPacks from './app/bsky/graph/getStarterPacks'
 import muteActor from './app/bsky/graph/muteActor'
 import unmuteActor from './app/bsky/graph/unmuteActor'
 import muteActorList from './app/bsky/graph/muteActorList'
@@ -75,6 +78,7 @@ export default function (server: Server, ctx: AppContext) {
   getProfile(server, ctx)
   getProfiles(server, ctx)
   getRepostedBy(server, ctx)
+  getActorStarterPacks(server, ctx)
   getBlocks(server, ctx)
   getListBlocks(server, ctx)
   getFollowers(server, ctx)
@@ -85,6 +89,8 @@ export default function (server: Server, ctx: AppContext) {
   getListMutes(server, ctx)
   getMutes(server, ctx)
   getRelationships(server, ctx)
+  getStarterPack(server, ctx)
+  getStarterPacks(server, ctx)
   muteActor(server, ctx)
   unmuteActor(server, ctx)
   muteActorList(server, ctx)

package/src/data-plane/server/db/database-schema.ts

@@ -34,6 +34,7 @@ import * as suggestedFeed from './tables/suggested-feed'
 import * as taggedSuggestion from './tables/tagged-suggestion'
 import * as blobTakedown from './tables/blob-takedown'
 import * as labeler from './tables/labeler'
+import * as starterPack from './tables/starter-pack'
 
 export type DatabaseSchemaType = duplicateRecord.PartialDB &
   profile.PartialDB &
@@ -69,6 +70,7 @@ export type DatabaseSchemaType = duplicateRecord.PartialDB &
   suggestedFeed.PartialDB &
   blobTakedown.PartialDB &
   labeler.PartialDB &
+  starterPack.PartialDB &
   taggedSuggestion.PartialDB
 
 export type DatabaseSchema = Kysely<DatabaseSchemaType>

package/src/data-plane/server/db/migrations/20240606T222548219Z-starter-packs.ts

@@ -0,0 +1,45 @@
+import { Kysely, sql } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('starter_pack')
+    .addColumn('uri', 'varchar', (col) => col.primaryKey())
+    .addColumn('cid', 'varchar', (col) => col.notNull())
+    .addColumn('creator', 'varchar', (col) => col.notNull())
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+    .addColumn('sortAt', 'varchar', (col) =>
+      col
+        .generatedAlwaysAs(sql`least("createdAt", "indexedAt")`)
+        .stored()
+        .notNull(),
+    )
+    .execute()
+  await db.schema
+    .createIndex('starter_pack_creator_order_by_idx')
+    .on('starter_pack')
+    .columns(['creator', 'sortAt', 'cid'])
+    .execute()
+  await db.schema
+    .alterTable('profile')
+    .addColumn('joinedViaStarterPackUri', 'varchar')
+    .execute()
+  await db.schema
+    .alterTable('profile')
+    .addColumn('createdAt', 'varchar', (col) => col.notNull())
+    .execute()
+  await db.schema
+    .createIndex('profile_starter_pack_joined_idx')
+    .on('profile')
+    .columns(['joinedViaStarterPackUri', 'createdAt'])
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('starter_pack').execute()
+  await db.schema
+    .alterTable('profile')
+    .dropColumn('joinedViaStarterPackUri')
+    .execute()
+  await db.schema.alterTable('profile').dropColumn('createdAt').execute()
+}

package/src/data-plane/server/db/migrations/index.ts

@@ -36,3 +36,4 @@ export * as _20240124T023719200Z from './20240124T023719200Z-tagged-suggestions'
 export * as _20240226T225725627Z from './20240226T225725627Z-labelers'
 export * as _20240530T170337073Z from './20240530T170337073Z-account-deactivation'
 export * as _20240606T171229898Z from './20240606T171229898Z-thread-mutes'
+export * as _20240606T222548219Z from './20240606T222548219Z-starter-packs'

package/src/data-plane/server/db/tables/profile.ts

@@ -8,6 +8,8 @@ export interface Profile {
   description: string | null
   avatarCid: string | null
   bannerCid: string | null
+  joinedViaStarterPackUri: string | null
+  createdAt: string
   indexedAt: string
 }
 export type PartialDB = { [tableName]: Profile }

package/src/data-plane/server/db/tables/starter-pack.ts

@@ -0,0 +1,16 @@
+import { GeneratedAlways } from 'kysely'
+
+export const tableName = 'starter_pack'
+
+export interface StarterPack {
+  uri: string
+  cid: string
+  creator: string
+  createdAt: string
+  indexedAt: string
+  sortAt: GeneratedAlways<string>
+}
+
+export type PartialDB = {
+  [tableName]: StarterPack
+}

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

@@ -26,6 +26,7 @@ import * as ListItem from './plugins/list-item'
 import * as ListBlock from './plugins/list-block'
 import * as Block from './plugins/block'
 import * as FeedGenerator from './plugins/feed-generator'
+import * as StarterPack from './plugins/starter-pack'
 import * as Labeler from './plugins/labeler'
 import * as ChatDeclaration from './plugins/chat-declaration'
 import RecordProcessor from './processor'
@@ -46,6 +47,7 @@ export class IndexingService {
     listBlock: ListBlock.PluginType
     block: Block.PluginType
     feedGenerator: FeedGenerator.PluginType
+    starterPack: StarterPack.PluginType
     labeler: Labeler.PluginType
     chatDeclaration: ChatDeclaration.PluginType
   }
@@ -67,6 +69,7 @@ export class IndexingService {
       listBlock: ListBlock.makePlugin(this.db, this.background),
       block: Block.makePlugin(this.db, this.background),
       feedGenerator: FeedGenerator.makePlugin(this.db, this.background),
+      starterPack: StarterPack.makePlugin(this.db, this.background),
       labeler: Labeler.makePlugin(this.db, this.background),
       chatDeclaration: ChatDeclaration.makePlugin(this.db, this.background),
     }

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

@@ -28,6 +28,8 @@ const insertFn = async (
       description: obj.description,
       avatarCid: obj.avatar?.ref.toString(),
       bannerCid: obj.banner?.ref.toString(),
+      joinedViaStarterPackUri: obj.joinedViaStarterPack?.uri,
+      createdAt: obj.createdAt ?? new Date().toISOString(),
       indexedAt: timestamp,
     })
     .onConflict((oc) => oc.doNothing())
@@ -40,8 +42,20 @@ const findDuplicate = async (): Promise<AtUri | null> => {
   return null
 }
 
-const notifsForInsert = () => {
-  return []
+const notifsForInsert = (obj: IndexedProfile) => {
+  if (!obj.joinedViaStarterPackUri) return []
+  const starterPackUri = new AtUri(obj.joinedViaStarterPackUri)
+  return [
+    {
+      did: starterPackUri.host,
+      author: obj.creator,
+      recordUri: obj.uri,
+      recordCid: obj.cid,
+      reason: 'starterpack-joined' as const,
+      reasonSubject: obj.joinedViaStarterPackUri,
+      sortAt: obj.indexedAt,
+    },
+  ]
 }
 
 const deleteFn = async (

package/src/data-plane/server/indexing/plugins/starter-pack.ts

@@ -0,0 +1,76 @@
+import { Selectable } from 'kysely'
+import { AtUri, normalizeDatetimeAlways } from '@atproto/syntax'
+import { CID } from 'multiformats/cid'
+import * as StarterPack from '../../../../lexicon/types/app/bsky/graph/starterpack'
+import * as lex from '../../../../lexicon/lexicons'
+import { Database } from '../../db'
+import { DatabaseSchema, DatabaseSchemaType } from '../../db/database-schema'
+import RecordProcessor from '../processor'
+import { BackgroundQueue } from '../../background'
+
+const lexId = lex.ids.AppBskyGraphStarterpack
+type IndexedStarterPack = Selectable<DatabaseSchemaType['starter_pack']>
+
+const insertFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+  cid: CID,
+  obj: StarterPack.Record,
+  timestamp: string,
+): Promise<IndexedStarterPack | null> => {
+  const inserted = await db
+    .insertInto('starter_pack')
+    .values({
+      uri: uri.toString(),
+      cid: cid.toString(),
+      creator: uri.host,
+      createdAt: normalizeDatetimeAlways(obj.createdAt),
+      indexedAt: timestamp,
+    })
+    .onConflict((oc) => oc.doNothing())
+    .returningAll()
+    .executeTakeFirst()
+  return inserted || null
+}
+
+const findDuplicate = async (): Promise<AtUri | null> => {
+  return null
+}
+
+const notifsForInsert = () => {
+  return []
+}
+
+const deleteFn = async (
+  db: DatabaseSchema,
+  uri: AtUri,
+): Promise<IndexedStarterPack | null> => {
+  const deleted = await db
+    .deleteFrom('starter_pack')
+    .where('uri', '=', uri.toString())
+    .returningAll()
+    .executeTakeFirst()
+  return deleted || null
+}
+
+const notifsForDelete = () => {
+  return { notifs: [], toDelete: [] }
+}
+
+export type PluginType = RecordProcessor<StarterPack.Record, IndexedStarterPack>
+
+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/routes/index.ts

@@ -22,6 +22,7 @@ import search from './search'
 import suggestions from './suggestions'
 import sync from './sync'
 import threads from './threads'
+import starterPacks from './starter-packs'
 import { Database } from '../db'
 
 export default (db: Database, idResolver: IdResolver) =>
@@ -48,6 +49,7 @@ export default (db: Database, idResolver: IdResolver) =>
       ...suggestions(db),
       ...sync(db),
       ...threads(db),
+      ...starterPacks(db),
 
       async ping() {
         return {}

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

@@ -1,4 +1,4 @@
-import { keyBy } from '@atproto/common'
+import { DAY, keyBy } from '@atproto/common'
 import { ServiceImpl } from '@connectrpc/connect'
 import { Service } from '../../../proto/bsky_connect'
 import { Database } from '../db'
@@ -24,7 +24,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   },
   async getCountsForUsers(req) {
     if (req.dids.length === 0) {
-      return { followers: [], following: [], posts: [] }
+      return {}
     }
     const { ref } = db.db.dynamic
     const res = await db.db
@@ -42,6 +42,11 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
           .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'),
       ])
       .execute()
     const byDid = keyBy(res, 'did')
@@ -51,6 +56,55 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
       posts: req.dids.map((uri) => byDid[uri]?.postsCount ?? 0),
       lists: req.dids.map((uri) => byDid[uri]?.listsCount ?? 0),
       feeds: req.dids.map((uri) => byDid[uri]?.feedGensCount ?? 0),
+      starterPacks: req.dids.map((uri) => byDid[uri]?.starterPacksCount ?? 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[uri]?.count ?? 0),
     }
   },
 })

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

@@ -54,6 +54,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
             ? chatDeclaration['allowIncoming']
             : undefined,
         upstreamStatus: row?.upstreamStatus ?? '',
+        createdAt: profiles.records[i].createdAt, // @NOTE profile creation date not trusted in production
       }
     })
     return { actors }

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

@@ -22,6 +22,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   getThreadGateRecords: getRecords(db, ids.AppBskyFeedThreadgate),
   getLabelerRecords: getRecords(db, ids.AppBskyLabelerService),
   getActorChatDeclarationRecords: getRecords(db, ids.ChatBskyActorDeclaration),
+  getStarterPackRecords: getRecords(db, ids.AppBskyGraphStarterpack),
 })
 
 export const getRecords =

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

@@ -0,0 +1,32 @@
+import { ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../../../proto/bsky_connect'
+import { Database } from '../db'
+import { TimeCidKeyset, paginate } from '../db/pagination'
+
+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/hydration/actor.ts

@@ -1,3 +1,4 @@
+import { Timestamp } from '@bufbuild/protobuf'
 import { DataPlaneClient } from '../data-plane/client'
 import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
 import { Record as ChatDeclarationRecord } from '../lexicon/types/chat/bsky/actor/declaration'
@@ -21,6 +22,7 @@ export type Actor = {
   isLabeler: boolean
   allowIncomingChatsFrom?: string
   upstreamStatus?: string
+  createdAt?: Date
 }
 
 export type Actors = HydrationMap<Actor>
@@ -54,6 +56,7 @@ export type ProfileAgg = {
   posts: number
   lists: number
   feeds: number
+  starterPacks: number
 }
 
 export type ProfileAggs = HydrationMap<ProfileAgg>
@@ -127,6 +130,7 @@ export class ActorHydrator {
         isLabeler: actor.labeler ?? false,
         allowIncomingChatsFrom: actor.allowIncomingChatsFrom || undefined,
         upstreamStatus: actor.upstreamStatus || undefined,
+        createdAt: actor.createdAt?.toDate(),
       })
     }, new HydrationMap<Actor>())
   }
@@ -211,6 +215,7 @@ export class ActorHydrator {
         posts: counts.posts[i] ?? 0,
         lists: counts.lists[i] ?? 0,
         feeds: counts.feeds[i] ?? 0,
+        starterPacks: counts.starterPacks[i] ?? 0,
       })
     }, new HydrationMap<ProfileAgg>())
   }

package/src/hydration/feed.ts

@@ -6,6 +6,7 @@ import { Record as FeedGenRecord } from '../lexicon/types/app/bsky/feed/generato
 import { Record as ThreadgateRecord } from '../lexicon/types/app/bsky/feed/threadgate'
 import {
   HydrationMap,
+  ItemRef,
   RecordInfo,
   parseRecord,
   parseString,
@@ -58,7 +59,6 @@ export type FeedGenViewerStates = HydrationMap<FeedGenViewerState>
 export type Threadgate = RecordInfo<ThreadgateRecord>
 export type Threadgates = HydrationMap<Threadgate>
 
-export type ItemRef = { uri: string; cid?: string }
 export type ThreadRef = ItemRef & { threadRoot: string }
 
 // @NOTE the feed item types in the protos for author feeds and timelines
@@ -203,7 +203,6 @@ export class FeedHydrator {
     }, new HydrationMap<Threadgate>())
   }
 
-  // @TODO may not be supported yet by data plane
   async getLikes(uris: string[], includeTakedowns = false): Promise<Likes> {
     if (!uris.length) return new HydrationMap<Like>()
     const res = await this.dataplane.getLikeRecords({ uris })

package/src/hydration/graph.ts

@@ -1,9 +1,10 @@
 import { Record as FollowRecord } from '../lexicon/types/app/bsky/graph/follow'
 import { Record as BlockRecord } from '../lexicon/types/app/bsky/graph/block'
+import { Record as StarterPackRecord } from '../lexicon/types/app/bsky/graph/starterpack'
 import { Record as ListRecord } from '../lexicon/types/app/bsky/graph/list'
 import { Record as ListItemRecord } from '../lexicon/types/app/bsky/graph/listitem'
 import { DataPlaneClient } from '../data-plane/client'
-import { HydrationMap, RecordInfo, parseRecord } from './util'
+import { HydrationMap, ItemRef, RecordInfo, parseRecord } from './util'
 import { FollowInfo } from '../proto/bsky_pb'
 
 export type List = RecordInfo<ListRecord>
@@ -25,6 +26,23 @@ export type Follows = HydrationMap<Follow>
 
 export type Block = RecordInfo<BlockRecord>
 
+export type StarterPack = RecordInfo<StarterPackRecord>
+export type StarterPacks = HydrationMap<StarterPack>
+
+export type StarterPackAgg = {
+  joinedWeek: number
+  joinedAllTime: number
+  listItemSampleUris?: string[] // gets set during starter pack hydration (not for basic view)
+}
+
+export type StarterPackAggs = HydrationMap<StarterPackAgg>
+
+export type ListAgg = {
+  listItems: number
+}
+
+export type ListAggs = HydrationMap<ListAgg>
+
 export type RelationshipPair = [didA: string, didB: string]
 
 const dedupePairs = (pairs: RelationshipPair[]): RelationshipPair[] => {
@@ -84,7 +102,6 @@ export class GraphHydrator {
     }, new HydrationMap<List>())
   }
 
-  // @TODO may not be supported yet by data plane
   async getListItems(
     uris: string[],
     includeTakedowns = false,
@@ -195,4 +212,40 @@ export class GraphHydrator {
     })
     return { followers: res.followers, cursor: res.cursor }
   }
+
+  async getStarterPacks(
+    uris: string[],
+    includeTakedowns = false,
+  ): Promise<StarterPacks> {
+    if (!uris.length) return new HydrationMap<StarterPack>()
+    const res = await this.dataplane.getStarterPackRecords({ uris })
+    return uris.reduce((acc, uri, i) => {
+      const record = parseRecord<StarterPackRecord>(
+        res.records[i],
+        includeTakedowns,
+      )
+      return acc.set(uri, record ?? null)
+    }, new HydrationMap<StarterPack>())
+  }
+
+  async getStarterPackAggregates(refs: ItemRef[]) {
+    if (!refs.length) return new HydrationMap<StarterPackAgg>()
+    const counts = await this.dataplane.getStarterPackCounts({ refs })
+    return refs.reduce((acc, { uri }, i) => {
+      return acc.set(uri, {
+        joinedWeek: counts.joinedWeek[i] ?? 0,
+        joinedAllTime: counts.joinedAllTime[i] ?? 0,
+      })
+    }, new HydrationMap<StarterPackAgg>())
+  }
+
+  async getListAggregates(refs: ItemRef[]) {
+    if (!refs.length) return new HydrationMap<ListAgg>()
+    const counts = await this.dataplane.getListCounts({ refs })
+    return refs.reduce((acc, { uri }, i) => {
+      return acc.set(uri, {
+        listItems: counts.listItems[i] ?? 0,
+      })
+    }, new HydrationMap<ListAgg>())
+  }
 }