@atproto/bsky 0.0.250 → 0.0.253

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

@@ -1,239 +0,0 @@
-import { Timestamp } from '@bufbuild/protobuf'
-import { ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { keyBy } from '@atproto/common'
-import { lexParse } from '@atproto/lex'
-import { app } from '../../../lexicons/index.js'
-import { Service } from '../../../proto/bsky_connect.js'
-import {
-  FilterableNotificationPreference,
-  NotificationInclude,
-  NotificationPreference,
-  NotificationPreferences,
-} from '../../../proto/bsky_pb.js'
-import { Namespaces } from '../../../stash.js'
-import { Database } from '../db/index.js'
-import { IsoSortAtKey } from '../db/pagination.js'
-import { countAll, notSoftDeletedClause } from '../db/util.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getNotifications(req) {
-    const { actorDid, limit, cursor, priority } = req
-    const { ref } = db.db.dynamic
-    const priorityFollowQb = db.db
-      .selectFrom('follow')
-      .select(sql<boolean>`${true}`.as('val'))
-      .where('creator', '=', actorDid)
-      .whereRef('subjectDid', '=', ref('notif.author'))
-      .limit(1)
-
-    let builder = db.db
-      .selectFrom('notification as notif')
-      .where('notif.did', '=', actorDid)
-      .where((eb) =>
-        eb.or([
-          eb('reasonSubject', 'is', null),
-          eb.exists(
-            db.db
-              .selectFrom('record as subject')
-              .selectAll()
-              .whereRef('subject.uri', '=', ref('notif.reasonSubject')),
-          ),
-        ]),
-      )
-      .$if(priority, (qb) => qb.where(({ exists }) => exists(priorityFollowQb)))
-      .select([
-        'notif.author as authorDid',
-        'notif.recordUri as uri',
-        'notif.recordCid as cid',
-        'notif.reason as reason',
-        'notif.reasonSubject as reasonSubject',
-        'notif.sortAt as sortAt',
-      ])
-      .select(priorityFollowQb.as('priority'))
-
-    const key = new IsoSortAtKey(ref('notif.sortAt'))
-    builder = key.paginate(builder, {
-      cursor,
-      limit,
-    })
-
-    const notifsRes = await builder.execute()
-    const notifications = notifsRes.map((notif) => ({
-      recipientDid: actorDid,
-      uri: notif.uri,
-      reason: notif.reason,
-      reasonSubject: notif.reasonSubject ?? undefined,
-      timestamp: Timestamp.fromDate(new Date(notif.sortAt)),
-      priority: notif.priority ?? false,
-    }))
-    return {
-      notifications,
-      cursor: key.packFromResult(notifsRes),
-    }
-  },
-
-  async getNotificationSeen(req) {
-    const { actorDid, priority } = req
-    const res = await db.db
-      .selectFrom('actor_state')
-      .where('did', '=', actorDid)
-      .selectAll()
-      .executeTakeFirst()
-    if (!res) {
-      return {}
-    }
-    const lastSeen =
-      priority && res.lastSeenPriorityNotifs
-        ? res.lastSeenPriorityNotifs
-        : res.lastSeenNotifs
-    return {
-      timestamp: Timestamp.fromDate(new Date(lastSeen)),
-    }
-  },
-
-  async getUnreadNotificationCount(req) {
-    const { actorDid, priority } = req
-    const { ref } = db.db.dynamic
-    const lastSeenRes = await db.db
-      .selectFrom('actor_state')
-      .where('did', '=', actorDid)
-      .selectAll()
-      .executeTakeFirst()
-    const lastSeen =
-      priority && lastSeenRes?.lastSeenPriorityNotifs
-        ? lastSeenRes.lastSeenPriorityNotifs
-        : lastSeenRes?.lastSeenNotifs
-
-    const result = await db.db
-      .selectFrom('notification')
-      .select(countAll.as('count'))
-      .innerJoin('actor', 'actor.did', 'notification.did')
-      .leftJoin('actor_state', 'actor_state.did', 'actor.did')
-      .innerJoin('record', 'record.uri', 'notification.recordUri')
-      .where(notSoftDeletedClause(ref('record')))
-      .where(notSoftDeletedClause(ref('actor')))
-      // Ensure to hit notification_did_sortat_idx, handling case where lastSeenNotifs is null.
-      .where('notification.did', '=', actorDid)
-      .where('notification.sortAt', '>', lastSeen ?? '')
-      .$if(priority, (qb) =>
-        qb.where(({ exists }) =>
-          exists(
-            db.db
-              .selectFrom('follow')
-              .select(sql<boolean>`${true}`.as('val'))
-              .where('creator', '=', actorDid)
-              .whereRef('subjectDid', '=', ref('notification.author')),
-          ),
-        ),
-      )
-      .executeTakeFirst()
-
-    return {
-      count: result?.count,
-    }
-  },
-
-  async updateNotificationSeen(req) {
-    const { actorDid, timestamp, priority } = req
-    if (!timestamp) {
-      return
-    }
-    const timestampIso = timestamp.toDate().toISOString()
-    let builder = db.db
-      .updateTable('actor_state')
-      .where('did', '=', actorDid)
-      .returningAll()
-    if (priority) {
-      builder = builder.set({ lastSeenPriorityNotifs: timestampIso })
-    } else {
-      builder = builder.set({ lastSeenNotifs: timestampIso })
-    }
-    const updateRes = await builder.executeTakeFirst()
-    if (updateRes) {
-      return
-    }
-    await db.db
-      .insertInto('actor_state')
-      .values({
-        did: actorDid,
-        lastSeenNotifs: timestampIso,
-        priorityNotifs: priority,
-        lastSeenPriorityNotifs: priority ? timestampIso : undefined,
-      })
-      .onConflict((oc) => oc.doNothing())
-      .executeTakeFirst()
-  },
-
-  async getNotificationPreferences(req) {
-    const { dids } = req
-    if (dids.length === 0) {
-      return { preferences: [] }
-    }
-
-    const res = await db.db
-      .selectFrom('private_data')
-      .selectAll()
-      .where('actorDid', 'in', dids)
-      .where(
-        'namespace',
-        '=',
-        Namespaces.AppBskyNotificationDefsPreferences.$type,
-      )
-      .where('key', '=', 'self')
-      .execute()
-
-    const byDid = keyBy(res, 'actorDid')
-    const preferences = dids.map((did) => {
-      const row = byDid.get(did)
-      if (!row) {
-        return {}
-      }
-      const p = lexParse<app.bsky.notification.defs.Preferences>(row.payload)
-      return notificationPreferencesLexToProtobuf(p, row.payload)
-    })
-
-    return { preferences }
-  },
-})
-
-export const notificationPreferencesLexToProtobuf = (
-  p: app.bsky.notification.defs.Preferences,
-  json: string,
-): NotificationPreferences => {
-  const lexFilterablePreferenceToProtobuf = (
-    p: app.bsky.notification.defs.FilterablePreference,
-  ): FilterableNotificationPreference =>
-    new FilterableNotificationPreference({
-      include:
-        p.include === 'follows'
-          ? NotificationInclude.FOLLOWS
-          : NotificationInclude.ALL,
-      list: { enabled: p.list ?? true },
-      push: { enabled: p.push ?? true },
-    })
-
-  const lexPreferenceToProtobuf = (
-    p: app.bsky.notification.defs.Preference,
-  ): NotificationPreference =>
-    new NotificationPreference({
-      list: { enabled: p.list ?? true },
-      push: { enabled: p.push ?? true },
-    })
-
-  return new NotificationPreferences({
-    entry: Buffer.from(json),
-    follow: lexFilterablePreferenceToProtobuf(p.follow),
-    like: lexFilterablePreferenceToProtobuf(p.like),
-    likeViaRepost: lexFilterablePreferenceToProtobuf(p.likeViaRepost),
-    mention: lexFilterablePreferenceToProtobuf(p.mention),
-    quote: lexFilterablePreferenceToProtobuf(p.quote),
-    reply: lexFilterablePreferenceToProtobuf(p.reply),
-    repost: lexFilterablePreferenceToProtobuf(p.repost),
-    repostViaRepost: lexFilterablePreferenceToProtobuf(p.repostViaRepost),
-    starterpackJoined: lexPreferenceToProtobuf(p.starterpackJoined),
-    subscribedPost: lexPreferenceToProtobuf(p.subscribedPost),
-    unverified: lexPreferenceToProtobuf(p.unverified),
-    verified: lexPreferenceToProtobuf(p.verified),
-  })
-}

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

@@ -1,220 +0,0 @@
-import { Timestamp } from '@bufbuild/protobuf'
-import { ServiceImpl } from '@connectrpc/connect'
-import { Selectable, sql } from 'kysely'
-import { keyBy } from '@atproto/common'
-import { parseJsonBytes } from '../../../hydration/util.js'
-import { app, chat } from '../../../lexicons/index.js'
-import { Service } from '../../../proto/bsky_connect.js'
-import { VerificationMeta } from '../../../proto/bsky_pb.js'
-import { Database } from '../db/index.js'
-import { Verification } from '../db/tables/verification.js'
-import { getRecords } from './records.js'
-
-type VerifiedBy = {
-  [handle: string]: Pick<
-    VerificationMeta,
-    'rkey' | 'handle' | 'displayName' | 'sortedAt'
-  >
-}
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  async getActors(req) {
-    const { dids, returnAgeAssuranceForDids } = req
-    if (dids.length === 0) {
-      return { actors: [] }
-    }
-    const profileUris = dids.map(
-      (did) => `at://${did}/app.bsky.actor.profile/self`,
-    )
-    const statusUris = dids.map(
-      (did) => `at://${did}/app.bsky.actor.status/self`,
-    )
-    const chatDeclarationUris = dids.map(
-      (did) => `at://${did}/chat.bsky.actor.declaration/self`,
-    )
-    const notifDeclarationUris = dids.map(
-      (did) => `at://${did}/app.bsky.notification.declaration/self`,
-    )
-    const germDeclarationUris = dids.map(
-      (did) => `at://${did}/com.germnetwork.declaration/self`,
-    )
-    const { ref } = db.db.dynamic
-    const [
-      handlesRes,
-      verificationsReceived,
-      profiles,
-      statuses,
-      chatDeclarations,
-      notifDeclarations,
-      germDeclarations,
-    ] = await Promise.all([
-      db.db
-        .selectFrom('actor')
-        .leftJoin('actor_state', 'actor_state.did', 'actor.did')
-        .where('actor.did', 'in', dids)
-        .selectAll('actor')
-        .select('actor_state.priorityNotifs')
-        .select([
-          db.db
-            .selectFrom('labeler')
-            .whereRef('creator', '=', ref('actor.did'))
-            .select(sql<true>`${true}`.as('val'))
-            .as('isLabeler'),
-        ])
-        .execute(),
-      db.db
-        .selectFrom('verification')
-        .selectAll('verification')
-        .innerJoin('actor', 'actor.did', 'verification.creator')
-        .where('verification.subject', 'in', dids)
-        .where('actor.trustedVerifier', '=', true)
-        .orderBy('sortedAt', 'asc')
-        .execute(),
-      getRecords(db)({ uris: profileUris }),
-      getRecords(db)({ uris: statusUris }),
-      getRecords(db)({ uris: chatDeclarationUris }),
-      getRecords(db)({ uris: notifDeclarationUris }),
-      getRecords(db)({ uris: germDeclarationUris }),
-    ])
-
-    const verificationsBySubjectDid = verificationsReceived.reduce(
-      (acc, cur) => {
-        const list = acc.get(cur.subject) ?? []
-        list.push(cur)
-        acc.set(cur.subject, list)
-        return acc
-      },
-      new Map<string, Selectable<Verification>[]>(),
-    )
-
-    const byDid = keyBy(handlesRes, 'did')
-    const actors = dids.map((did, i) => {
-      const row = byDid.get(did)
-
-      const status = statuses.records[i]
-
-      const chatDeclaration = parseJsonBytes(
-        chat.bsky.actor.declaration.main,
-        chatDeclarations.records[i].record,
-      )
-
-      const germDeclaration = germDeclarations.records[i]
-
-      const verifications = verificationsBySubjectDid.get(did) ?? []
-      const verifiedBy: VerifiedBy = verifications.reduce((acc, cur) => {
-        acc[cur.creator] = {
-          rkey: cur.rkey,
-          handle: cur.handle,
-          displayName: cur.displayName,
-          sortedAt: Timestamp.fromDate(new Date(cur.sortedAt)),
-        }
-        return acc
-      }, {} as VerifiedBy)
-      const ageAssuranceForDids = new Set(returnAgeAssuranceForDids)
-
-      const activitySubscription = () => {
-        const record = parseJsonBytes(
-          app.bsky.notification.declaration.main,
-          notifDeclarations.records[i].record,
-        )
-
-        // The dataplane is responsible for setting the default of "followers" (default according to the lexicon).
-        const defaultVal = 'followers'
-
-        if (typeof record?.allowSubscriptions !== 'string') {
-          return defaultVal
-        }
-
-        switch (record.allowSubscriptions) {
-          case 'followers':
-          case 'mutuals':
-          case 'none':
-            return record.allowSubscriptions
-          default:
-            return defaultVal
-        }
-      }
-
-      const ageAssuranceStatus = () => {
-        if (!ageAssuranceForDids.has(did)) {
-          return undefined
-        }
-
-        const status = row?.ageAssuranceStatus ?? 'unknown'
-        let access = row?.ageAssuranceAccess
-        if (!access || access === 'unknown') {
-          if (status === 'assured') {
-            access = 'full'
-          } else if (status === 'blocked') {
-            access = 'none'
-          } else {
-            access = 'unknown'
-          }
-        }
-
-        return {
-          lastInitiatedAt: row?.ageAssuranceLastInitiatedAt
-            ? Timestamp.fromDate(new Date(row?.ageAssuranceLastInitiatedAt))
-            : undefined,
-          status,
-          access,
-        }
-      }
-
-      return {
-        exists: !!row,
-        handle: row?.handle ?? undefined,
-        profile: profiles.records[i],
-        takenDown: !!row?.takedownRef,
-        takedownRef: row?.takedownRef || undefined,
-        tombstonedAt: undefined, // in current implementation, tombstoned actors are deleted
-        labeler: row?.isLabeler ?? false,
-        allowIncomingChatsFrom:
-          typeof chatDeclaration?.['allowIncoming'] === 'string'
-            ? chatDeclaration['allowIncoming']
-            : undefined,
-        allowGroupChatInvitesFrom:
-          typeof chatDeclaration?.['allowGroupInvites'] === 'string'
-            ? chatDeclaration['allowGroupInvites']
-            : undefined,
-        upstreamStatus: row?.upstreamStatus ?? '',
-        createdAt: profiles.records[i].createdAt, // @NOTE profile creation date not trusted in production
-        priorityNotifications: row?.priorityNotifs ?? false,
-        trustedVerifier: row?.trustedVerifier ?? false,
-        verifiedBy,
-        statusRecord: status,
-        germRecord: germDeclaration,
-        tags: [],
-        profileTags: [],
-        allowActivitySubscriptionsFrom: activitySubscription(),
-        ageAssuranceStatus: ageAssuranceStatus(),
-      }
-    })
-    return { actors }
-  },
-
-  // @TODO handle req.lookupUnidirectional w/ networked handle resolution
-  async getDidsByHandles(req) {
-    const { handles } = req
-    if (handles.length === 0) {
-      return { dids: [] }
-    }
-    const res = await db.db
-      .selectFrom('actor')
-      .where('handle', 'in', handles)
-      .selectAll()
-      .execute()
-    const byHandle = keyBy(res, 'handle')
-    const dids = handles.map((handle) => byHandle.get(handle)?.did ?? '')
-    return { dids }
-  },
-
-  async updateActorUpstreamStatus(req) {
-    const { actorDid, upstreamStatus } = req
-    await db.db
-      .updateTable('actor')
-      .set({ upstreamStatus })
-      .where('did', '=', actorDid)
-      .execute()
-  },
-})

package/src/data-plane/server/routes/quotes.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 getQuotesBySubjectSorted(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 {
-      uris: quotes.map((q) => q.uri),
-      cursor: keyset.packFromResult(quotes),
-    }
-  },
-})

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

@@ -1,119 +0,0 @@
-import { Timestamp } from '@bufbuild/protobuf'
-import { ServiceImpl } from '@connectrpc/connect'
-import * as ui8 from 'uint8arrays'
-import { keyBy } from '@atproto/common'
-import { l } from '@atproto/lex'
-import { AtUri } from '@atproto/syntax'
-import { app, chat, com } from '../../../lexicons/index.js'
-import { Service } from '../../../proto/bsky_connect.js'
-import { PostRecordMeta, Record } from '../../../proto/bsky_pb.js'
-import { Database } from '../db/index.js'
-
-export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
-  getBlockRecords: getRecords(db, app.bsky.graph.block),
-  getFeedGeneratorRecords: getRecords(db, app.bsky.feed.generator),
-  getFollowRecords: getRecords(db, app.bsky.graph.follow),
-  getLikeRecords: getRecords(db, app.bsky.feed.like),
-  getListBlockRecords: getRecords(db, app.bsky.graph.listblock),
-  getListItemRecords: getRecords(db, app.bsky.graph.listitem),
-  getListRecords: getRecords(db, app.bsky.graph.list),
-  getPostRecords: getPostRecords(db),
-  getProfileRecords: getRecords(db, app.bsky.actor.profile),
-  getRepostRecords: getRecords(db, app.bsky.feed.repost),
-  getThreadGateRecords: getRecords(db, app.bsky.feed.threadgate),
-  getPostgateRecords: getRecords(db, app.bsky.feed.postgate),
-  getLabelerRecords: getRecords(db, app.bsky.labeler.service),
-  getActorChatDeclarationRecords: getRecords(db, chat.bsky.actor.declaration),
-  getNotificationDeclarationRecords: getRecords(
-    db,
-    app.bsky.notification.declaration,
-  ),
-  getGermDeclarationRecords: getRecords(db, com.germnetwork.declaration),
-  getStarterPackRecords: getRecords(db, app.bsky.graph.starterpack),
-  getVerificationRecords: getRecords(db, app.bsky.graph.verification),
-  getStatusRecords: getRecords(db, app.bsky.actor.status),
-})
-
-export const getRecords = (db: Database, ns?: l.Main<l.RecordSchema>) => {
-  const collection = ns ? l.getMain(ns).$type : undefined
-
-  return async (req: { uris: string[] }): Promise<{ records: Record[] }> => {
-    const validUris = collection
-      ? req.uris.filter((uri) => new AtUri(uri).collection === collection)
-      : req.uris
-    const res = validUris.length
-      ? await db.db
-          .selectFrom('record')
-          .selectAll()
-          .where('uri', 'in', validUris)
-          .execute()
-      : []
-    const byUri = keyBy(res, 'uri')
-    const records: Record[] = req.uris.map((uri) => {
-      const row = byUri.get(uri)
-      const json = row ? row.json : JSON.stringify(null)
-      const createdAtRaw = new Date(JSON.parse(json)?.['createdAt'])
-      const createdAt = !isNaN(createdAtRaw.getTime())
-        ? Timestamp.fromDate(createdAtRaw)
-        : undefined
-      const indexedAt = row?.indexedAt
-        ? Timestamp.fromDate(new Date(row?.indexedAt))
-        : undefined
-      const recordBytes = ui8.fromString(json, 'utf8')
-      return new Record({
-        record: recordBytes as Uint8Array<ArrayBuffer>,
-        cid: row?.cid,
-        createdAt,
-        indexedAt,
-        sortedAt: compositeTime(createdAt, indexedAt),
-        takenDown: !!row?.takedownRef,
-        takedownRef: row?.takedownRef ?? undefined,
-        tags: row?.tags ?? undefined,
-      })
-    })
-    return { records }
-  }
-}
-
-export const getPostRecords = (db: Database) => {
-  const getBaseRecords = getRecords(db, app.bsky.feed.post)
-  return async (req: {
-    uris: string[]
-  }): Promise<{ records: Record[]; meta: PostRecordMeta[] }> => {
-    const [{ records }, details] = await Promise.all([
-      getBaseRecords(req),
-      req.uris.length
-        ? await db.db
-            .selectFrom('post')
-            .where('uri', 'in', req.uris)
-            .select([
-              'uri',
-              'violatesThreadGate',
-              'violatesEmbeddingRules',
-              'hasThreadGate',
-              'hasPostGate',
-            ])
-            .execute()
-        : [],
-    ])
-    const byKey = keyBy(details, 'uri')
-    const meta = req.uris.map((uri) => {
-      return new PostRecordMeta({
-        violatesThreadGate: !!byKey.get(uri)?.violatesThreadGate,
-        violatesEmbeddingRules: !!byKey.get(uri)?.violatesEmbeddingRules,
-        hasThreadGate: !!byKey.get(uri)?.hasThreadGate,
-        hasPostGate: !!byKey.get(uri)?.hasPostGate,
-      })
-    })
-    return { records, meta }
-  }
-}
-
-const compositeTime = (
-  ts1: Timestamp | undefined,
-  ts2: Timestamp | undefined,
-) => {
-  if (!ts1) return ts2
-  if (!ts2) return ts1
-  return ts1.toDate() < ts2.toDate() ? ts1 : ts2
-}