@atproto/bsky 0.0.251 → 0.0.254

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

@@ -1,55 +0,0 @@
-import { ServiceImpl } from '@connectrpc/connect'
-import { Selectable, sql } from 'kysely'
-import * as ui8 from 'uint8arrays'
-import { noUndefinedVals } from '@atproto/common'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import { Label } from '../db/tables/label.js'
-
-type LabelRow = Selectable<Label>
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getLabels(req) {
-    const { subjects, issuers } = req
-    if (subjects.length === 0 || issuers.length === 0) {
-      return { labels: [] }
-    }
-
-    const res: LabelRow[] = await db.db
-      .selectFrom('label')
-      .where('uri', 'in', subjects)
-      .where('src', 'in', issuers)
-      .where((eb) =>
-        eb.or([eb('exp', 'is', null), sql<boolean>`exp::timestamp > now()`]),
-      )
-      .selectAll()
-      .execute()
-
-    const labelsBySubject = new Map<string, LabelRow[]>()
-    res.forEach((l) => {
-      const labels = labelsBySubject.get(l.uri) ?? []
-      labels.push(l)
-      labelsBySubject.set(l.uri, labels)
-    })
-
-    // intentionally duplicate label results, appview frontend should be defensive to this
-    const labels = subjects.flatMap((sub) => {
-      const labelsForSub = labelsBySubject.get(sub) ?? []
-      return labelsForSub.map((l) => {
-        const formatted = noUndefinedVals({
-          ...l,
-          exp: l.exp === null ? undefined : l.exp,
-          cid: l.cid === '' ? undefined : l.cid,
-          neg: l.neg === true ? true : undefined,
-        })
-        return ui8.fromString(JSON.stringify(formatted), 'utf8')
-      })
-    })
-
-    return { labels }
-  },
-
-  async getAllLabelers() {
-    throw new Error('not implemented')
-  },
-})

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

@@ -1,92 +0,0 @@
-import assert from 'node:assert'
-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 getLikesBySubjectSorted(req) {
-    const { subject, cursor, limit } = req
-    const { ref } = db.db.dynamic
-
-    if (!subject?.uri) {
-      return { uris: [] }
-    }
-
-    // @NOTE ignoring subject.cid
-    let builder = db.db
-      .selectFrom('like')
-      .where('like.subject', '=', subject?.uri)
-      .selectAll('like')
-
-    const keyset = new TimeCidKeyset(ref('like.sortAt'), ref('like.cid'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-
-    const likes = await builder.execute()
-
-    return {
-      uris: likes.map((l) => l.uri),
-      cursor: keyset.packFromResult(likes),
-    }
-  },
-
-  // @NOTE deprecated in favor of getLikesBySubjectSorted
-  async getLikesBySubject(req, context) {
-    assert(this.getLikesBySubjectSorted)
-    return this.getLikesBySubjectSorted(req, context)
-  },
-
-  async getLikesByActorAndSubjects(req) {
-    const { actorDid, refs } = req
-    if (refs.length === 0) {
-      return { uris: [] }
-    }
-    // @NOTE ignoring ref.cid
-    const res = await db.db
-      .selectFrom('like')
-      .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 getActorLikes(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-
-    let builder = db.db
-      .selectFrom('like')
-      .where('like.creator', '=', actorDid)
-      .selectAll()
-
-    const keyset = new TimeCidKeyset(ref('like.sortAt'), ref('like.cid'))
-
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-
-    const likes = await builder.execute()
-
-    return {
-      likes: likes.map((l) => ({
-        uri: l.uri,
-        subject: l.subject,
-      })),
-      cursor: keyset.packFromResult(likes),
-    }
-  },
-})

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

@@ -1,88 +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'
-import { countAll } from '../db/util.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getActorLists(req) {
-    const { actorDid, cursor, limit } = req
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('list')
-      .where('creator', '=', actorDid)
-      .selectAll()
-    const keyset = new TimeCidKeyset(ref('list.sortAt'), ref('list.cid'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-    const lists = await builder.execute()
-    return {
-      listUris: lists.map((item) => item.uri),
-      cursor: keyset.packFromResult(lists),
-    }
-  },
-
-  async getListMembers(req) {
-    const { listUri, cursor, limit } = req
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('list_item')
-      .where('listUri', '=', listUri)
-      .selectAll()
-
-    const keyset = new TimeCidKeyset(
-      ref('list_item.sortAt'),
-      ref('list_item.cid'),
-    )
-
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-      tryIndex: true,
-    })
-
-    const listItems = await builder.execute()
-    return {
-      listitems: listItems.map((item) => ({
-        uri: item.uri,
-        did: item.subjectDid,
-      })),
-      cursor: keyset.packFromResult(listItems),
-    }
-  },
-
-  async getListMembership(req) {
-    const { actorDid, listUris } = req
-    if (listUris.length === 0) {
-      return { listitemUris: [] }
-    }
-    const res = await db.db
-      .selectFrom('list_item')
-      .where('subjectDid', '=', actorDid)
-      .where('listUri', 'in', listUris)
-      .selectAll()
-      .execute()
-    const byListUri = keyBy(res, 'listUri')
-    const listitemUris = listUris.map((uri) => byListUri.get(uri)?.uri ?? '')
-    return {
-      listitemUris,
-    }
-  },
-
-  async getListCount(req) {
-    const res = await db.db
-      .selectFrom('list_item')
-      .select(countAll.as('count'))
-      .where('list_item.listUri', '=', req.listUri)
-      .executeTakeFirst()
-    return {
-      count: res?.count,
-    }
-  },
-})

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

@@ -1,102 +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 getActorTakedown(req) {
-    const { did } = req
-    const res = await db.db
-      .selectFrom('actor')
-      .where('did', '=', did)
-      .select('takedownRef')
-      .executeTakeFirst()
-    return {
-      takenDown: !!res?.takedownRef,
-      takedownRef: res?.takedownRef || undefined,
-    }
-  },
-
-  async getBlobTakedown(req) {
-    const { did, cid } = req
-    const res = await db.db
-      .selectFrom('blob_takedown')
-      .where('did', '=', did)
-      .where('cid', '=', cid)
-      .select('takedownRef')
-      .executeTakeFirst()
-    return {
-      takenDown: !!res,
-      takedownRef: res?.takedownRef || undefined,
-    }
-  },
-
-  async getRecordTakedown(req) {
-    const { recordUri } = req
-    const res = await db.db
-      .selectFrom('record')
-      .where('uri', '=', recordUri)
-      .select('takedownRef')
-      .executeTakeFirst()
-    return {
-      takenDown: !!res?.takedownRef,
-      takedownRef: res?.takedownRef || undefined,
-    }
-  },
-
-  async takedownActor(req) {
-    const { did, ref } = req
-    await db.db
-      .updateTable('actor')
-      .set({ takedownRef: ref || 'TAKEDOWN' })
-      .where('did', '=', did)
-      .execute()
-  },
-
-  async takedownBlob(req) {
-    const { did, cid, ref } = req
-    await db.db
-      .insertInto('blob_takedown')
-      .values({
-        did,
-        cid,
-        takedownRef: ref || 'TAKEDOWN',
-      })
-      .execute()
-  },
-
-  async takedownRecord(req) {
-    const { recordUri, ref } = req
-    await db.db
-      .updateTable('record')
-      .set({ takedownRef: ref || 'TAKEDOWN' })
-      .where('uri', '=', recordUri)
-      .execute()
-  },
-
-  async untakedownActor(req) {
-    const { did } = req
-    await db.db
-      .updateTable('actor')
-      .set({ takedownRef: null })
-      .where('did', '=', did)
-      .execute()
-  },
-
-  async untakedownBlob(req) {
-    const { did, cid } = req
-    await db.db
-      .deleteFrom('blob_takedown')
-      .where('did', '=', did)
-      .where('cid', '=', cid)
-      .executeTakeFirst()
-  },
-
-  async untakedownRecord(req) {
-    const { recordUri } = req
-    await db.db
-      .updateTable('record')
-      .set({ takedownRef: null })
-      .where('uri', '=', recordUri)
-      .execute()
-  },
-})

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

@@ -1,195 +0,0 @@
-import assert from 'node:assert'
-import { ServiceImpl } from '@connectrpc/connect'
-import { keyBy } from '@atproto/common'
-import { AtUri } from '@atproto/syntax'
-import { app } from '../../../lexicons/index.js'
-import { Service } from '../../../proto/bsky_connect.js'
-import { Database } from '../db/index.js'
-import {
-  CreatedAtDidKeyset,
-  TimeCidKeyset,
-  paginate,
-} from '../db/pagination.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getActorMutesActor(req) {
-    const { actorDid, targetDid } = req
-    const res = await db.db
-      .selectFrom('mute')
-      .selectAll()
-      .where('mutedByDid', '=', actorDid)
-      .where('subjectDid', '=', targetDid)
-      .executeTakeFirst()
-    return {
-      muted: !!res,
-    }
-  },
-
-  async getMutes(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-
-    let builder = db.db
-      .selectFrom('mute')
-      .innerJoin('actor', 'actor.did', 'mute.subjectDid')
-      .where('mute.mutedByDid', '=', actorDid)
-      .selectAll('actor')
-      .select('mute.createdAt as createdAt')
-
-    const keyset = new CreatedAtDidKeyset(
-      ref('mute.createdAt'),
-      ref('mute.subjectDid'),
-    )
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-
-    const mutes = await builder.execute()
-
-    return {
-      dids: mutes.map((m) => m.did),
-      cursor: keyset.packFromResult(mutes),
-    }
-  },
-
-  async getActorMutesActorViaList(req) {
-    const { actorDid, targetDid } = req
-    const res = await db.db
-      .selectFrom('list_mute')
-      .innerJoin('list_item', 'list_item.listUri', 'list_mute.listUri')
-      .where('list_mute.mutedByDid', '=', actorDid)
-      .where('list_item.subjectDid', '=', targetDid)
-      .select('list_mute.listUri')
-      .limit(1)
-      .executeTakeFirst()
-    return {
-      listUri: res?.listUri,
-    }
-  },
-
-  async getMutelistSubscription(req) {
-    const { actorDid, listUri } = req
-    const res = await db.db
-      .selectFrom('list_mute')
-      .where('mutedByDid', '=', actorDid)
-      .where('listUri', '=', listUri)
-      .selectAll()
-      .limit(1)
-      .executeTakeFirst()
-    return {
-      subscribed: !!res,
-    }
-  },
-
-  async getMutelistSubscriptions(req) {
-    const { actorDid, limit, cursor } = req
-    const { ref } = db.db.dynamic
-    let builder = db.db
-      .selectFrom('list')
-      .where(({ exists }) =>
-        exists(
-          db.db
-            .selectFrom('list_mute')
-            .where('list_mute.mutedByDid', '=', actorDid)
-            .whereRef('list_mute.listUri', '=', ref('list.uri'))
-            .selectAll(),
-        ),
-      )
-      .selectAll('list')
-
-    const keyset = new TimeCidKeyset(ref('list.createdAt'), ref('list.cid'))
-    builder = paginate(builder, {
-      limit,
-      cursor,
-      keyset,
-    })
-    const lists = await builder.execute()
-
-    return {
-      listUris: lists.map((l) => l.uri),
-      cursor: keyset.packFromResult(lists),
-    }
-  },
-
-  async createActorMute(req) {
-    const { actorDid, subjectDid } = req
-    assert(actorDid !== subjectDid, 'cannot mute yourself') // @TODO pass message through in http error
-    await db.db
-      .insertInto('mute')
-      .values({
-        subjectDid,
-        mutedByDid: actorDid,
-        createdAt: new Date().toISOString(),
-      })
-      .onConflict((oc) => oc.doNothing())
-      .execute()
-  },
-
-  async deleteActorMute(req) {
-    const { actorDid, subjectDid } = req
-    assert(actorDid !== subjectDid, 'cannot mute yourself')
-    await db.db
-      .deleteFrom('mute')
-      .where('subjectDid', '=', subjectDid)
-      .where('mutedByDid', '=', actorDid)
-      .execute()
-  },
-
-  async clearActorMutes(req) {
-    const { actorDid } = req
-    await db.db.deleteFrom('mute').where('mutedByDid', '=', actorDid).execute()
-  },
-
-  async createActorMutelistSubscription(req) {
-    const { actorDid, subjectUri } = req
-    assert(isListUri(subjectUri), 'must mute a list')
-    await db.db
-      .insertInto('list_mute')
-      .values({
-        listUri: subjectUri,
-        mutedByDid: actorDid,
-        createdAt: new Date().toISOString(),
-      })
-      .onConflict((oc) => oc.doNothing())
-      .execute()
-  },
-
-  async deleteActorMutelistSubscription(req) {
-    const { actorDid, subjectUri } = req
-    assert(isListUri(subjectUri), 'must mute a list')
-    await db.db
-      .deleteFrom('list_mute')
-      .where('listUri', '=', subjectUri)
-      .where('mutedByDid', '=', actorDid)
-      .execute()
-  },
-
-  async clearActorMutelistSubscriptions(req) {
-    const { actorDid } = req
-    await db.db
-      .deleteFrom('list_mute')
-      .where('mutedByDid', '=', actorDid)
-      .execute()
-  },
-
-  async getThreadMutesOnSubjects(req) {
-    const { actorDid, threadRoots } = req
-    if (threadRoots.length === 0) {
-      return { muted: [] }
-    }
-    const res = await db.db
-      .selectFrom('thread_mute')
-      .selectAll()
-      .where('mutedByDid', '=', actorDid)
-      .where('rootUri', 'in', threadRoots)
-      .execute()
-    const byRootUri = keyBy(res, 'rootUri')
-    const muted = threadRoots.map((uri) => !!byRootUri.get(uri))
-    return { muted }
-  },
-})
-
-const isListUri = (uri: string) =>
-  new AtUri(uri).collection === app.bsky.graph.list.$type