@atproto/bsky 0.0.166 → 0.0.167

package/src/api/app/bsky/notification/listActivitySubscriptions.ts

@@ -0,0 +1,110 @@
+import { mapDefined } from '@atproto/common'
+import { AppContext } from '../../../../context'
+import { HydrateCtx, Hydrator } from '../../../../hydration/hydrator'
+import { Server } from '../../../../lexicon'
+import { QueryParams } from '../../../../lexicon/types/app/bsky/notification/listActivitySubscriptions'
+import {
+  HydrationFnInput,
+  PresentationFnInput,
+  RulesFnInput,
+  SkeletonFnInput,
+  createPipeline,
+} from '../../../../pipeline'
+import { Views } from '../../../../views'
+import { clearlyBadCursor, resHeaders } from '../../../util'
+
+export default function (server: Server, ctx: AppContext) {
+  const listActivitySubscriptions = createPipeline(
+    skeleton,
+    hydration,
+    noBlocks,
+    presentation,
+  )
+  server.app.bsky.notification.listActivitySubscriptions({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ params, auth, req }) => {
+      const viewer = auth.credentials.iss
+      const labelers = ctx.reqLabelers(req)
+      const hydrateCtx = await ctx.hydrator.createContext({
+        labelers,
+        viewer,
+      })
+
+      const result = await listActivitySubscriptions(
+        { ...params, hydrateCtx: hydrateCtx.copy({ viewer }) },
+        ctx,
+      )
+
+      return {
+        encoding: 'application/json',
+        body: result,
+        headers: resHeaders({ labelers: hydrateCtx.labelers }),
+      }
+    },
+  })
+}
+
+const skeleton = async (input: SkeletonFnInput<Context, Params>) => {
+  const { params, ctx } = input
+  const actorDid = params.hydrateCtx.viewer
+  if (clearlyBadCursor(params.cursor)) {
+    return { actorDid, dids: [] }
+  }
+  const { dids, cursor } =
+    await ctx.hydrator.dataplane.getActivitySubscriptionDids({
+      actorDid: params.hydrateCtx.viewer,
+      limit: params.limit,
+      cursor: params.cursor,
+    })
+  return {
+    actorDid,
+    dids,
+    cursor: cursor || undefined,
+  }
+}
+
+const hydration = async (
+  input: HydrationFnInput<Context, Params, SkeletonState>,
+) => {
+  const { ctx, params, skeleton } = input
+  const { dids } = skeleton
+  const state = await ctx.hydrator.hydrateProfilesDetailed(
+    dids,
+    params.hydrateCtx,
+  )
+  return state
+}
+
+const noBlocks = (input: RulesFnInput<Context, Params, SkeletonState>) => {
+  const { skeleton, hydration, ctx } = input
+  skeleton.dids = skeleton.dids.filter(
+    (did) => !ctx.views.viewerBlockExists(did, hydration),
+  )
+  return skeleton
+}
+
+const presentation = (
+  input: PresentationFnInput<Context, Params, SkeletonState>,
+) => {
+  const { ctx, hydration, skeleton } = input
+  const { dids, cursor } = skeleton
+  const subscriptions = mapDefined(dids, (did) => {
+    return ctx.views.profile(did, hydration)
+  })
+  return { subscriptions, cursor }
+}
+
+type Context = {
+  hydrator: Hydrator
+  views: Views
+}
+
+type Params = QueryParams & {
+  hydrateCtx: HydrateCtx & { viewer: string }
+}
+
+type SkeletonState = {
+  actorDid: string
+  dids: string[]
+  cursor?: string
+}

package/src/api/app/bsky/notification/putActivitySubscription.ts

@@ -0,0 +1,69 @@
+import { TID } from '@atproto/common'
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../../../context'
+import { isActivitySubscriptionEnabled } from '../../../../hydration/util'
+import { Server } from '../../../../lexicon'
+import { Namespaces } from '../../../../stash'
+
+export default function (server: Server, ctx: AppContext) {
+  server.app.bsky.notification.putActivitySubscription({
+    auth: ctx.authVerifier.standard,
+    handler: async ({ input, auth }) => {
+      const actorDid = auth.credentials.iss
+      const { subject, activitySubscription } = input.body
+      if (actorDid === subject) {
+        throw new InvalidRequestError('Cannot subscribe to own activity')
+      }
+
+      const existingKey = await getExistingKey(ctx, actorDid, subject)
+      const enabled = isActivitySubscriptionEnabled(activitySubscription)
+
+      const stashInput = {
+        actorDid,
+        namespace:
+          Namespaces.AppBskyNotificationDefsSubjectActivitySubscription,
+        payload: {
+          subject,
+          activitySubscription,
+        },
+        key: existingKey ?? TID.nextStr(),
+      }
+
+      if (existingKey) {
+        if (enabled) {
+          await ctx.stashClient.update(stashInput)
+        } else {
+          await ctx.stashClient.delete(stashInput)
+        }
+      } else {
+        if (enabled) {
+          await ctx.stashClient.create(stashInput)
+        } else {
+          // no-op: subscription already doesn't exist
+        }
+      }
+
+      return {
+        encoding: 'application/json',
+        body: {
+          subject,
+          activitySubscription: enabled ? activitySubscription : undefined,
+        },
+      }
+    },
+  })
+}
+
+const getExistingKey = async (
+  ctx: AppContext,
+  actorDid: string,
+  subject: string,
+): Promise<string | null> => {
+  const res = await ctx.dataplane.getActivitySubscriptionsByActorAndSubjects({
+    actorDid,
+    subjectDids: [subject],
+  })
+  const [existing] = res.subscriptions
+  const key = existing.key
+  return key || null
+}

package/src/api/app/bsky/notification/putPreferencesV2.ts

@@ -6,6 +6,7 @@ import { Server } from '../../../../lexicon'
 import { Preferences } from '../../../../lexicon/types/app/bsky/notification/defs'
 import { HandlerInput } from '../../../../lexicon/types/app/bsky/notification/putPreferencesV2'
 import { GetNotificationPreferencesResponse } from '../../../../proto/bsky_pb'
+import { Namespaces } from '../../../../stash'
 import { protobufToLex } from './util'
 
 export default function (server: Server, ctx: AppContext) {
@@ -18,7 +19,7 @@ export default function (server: Server, ctx: AppContext) {
       // Notification preferences are created automatically on the dataplane on signup, so we just update.
       await ctx.stashClient.update({
         actorDid,
-        namespace: 'app.bsky.notification.defs#preferences',
+        namespace: Namespaces.AppBskyNotificationDefsPreferences,
         key: 'self',
         payload: preferences,
       })

package/src/api/index.ts

@@ -44,7 +44,9 @@ import unmuteThread from './app/bsky/graph/unmuteThread'
 import getLabelerServices from './app/bsky/labeler/getServices'
 import getPreferences from './app/bsky/notification/getPreferences'
 import getUnreadCount from './app/bsky/notification/getUnreadCount'
+import listActivitySubscriptions from './app/bsky/notification/listActivitySubscriptions'
 import listNotifications from './app/bsky/notification/listNotifications'
+import putActivitySubscription from './app/bsky/notification/putActivitySubscription'
 import putPreferences from './app/bsky/notification/putPreferences'
 import putPreferencesV2 from './app/bsky/notification/putPreferencesV2'
 import registerPush from './app/bsky/notification/registerPush'
@@ -126,7 +128,9 @@ export default function (server: Server, ctx: AppContext) {
   getSuggestions(server, ctx)
   getPreferences(server, ctx)
   getUnreadCount(server, ctx)
+  listActivitySubscriptions(server, ctx)
   listNotifications(server, ctx)
+  putActivitySubscription(server, ctx)
   updateSeen(server, ctx)
   putPreferences(server, ctx)
   putPreferencesV2(server, ctx)

package/src/data-plane/bsync/index.ts

@@ -5,8 +5,11 @@ import { ConnectRouter } from '@connectrpc/connect'
 import { expressConnectMiddleware } from '@connectrpc/connect-express'
 import express from 'express'
 import { TID } from '@atproto/common'
+import { jsonStringToLex } from '@atproto/lexicon'
 import { AtUri } from '@atproto/syntax'
 import { ids } from '../../lexicon/lexicons'
+import { SubjectActivitySubscription } from '../../lexicon/types/app/bsky/notification/defs'
+import { httpLogger } from '../../logger'
 import { Service } from '../../proto/bsync_connect'
 import {
   Method,
@@ -15,6 +18,7 @@ import {
 } from '../../proto/bsync_pb'
 import { Namespaces } from '../../stash'
 import { Database } from '../server/db'
+import { excluded } from '../server/db/util'
 
 export class MockBsync {
   constructor(public server: http.Server) {}
@@ -146,19 +150,30 @@ const createRoutes = (db: Database) => (router: ConnectRouter) =>
 
     async putOperation(req) {
       const { actorDid, namespace, key, method, payload } = req
-      if (
-        method !== Method.CREATE &&
-        method !== Method.UPDATE &&
-        method !== Method.DELETE
-      ) {
-        throw new Error(`Unsupported method: ${method}`)
-      }
+      assert(
+        method === Method.CREATE ||
+          method === Method.UPDATE ||
+          method === Method.DELETE,
+        `Unsupported method: ${method}`,
+      )
 
       const now = new Date().toISOString()
-      if (namespace === Namespaces.AppBskyNotificationDefsPreferences) {
-        await handleNotificationPreferencesOperation(db, req, now)
-      } else {
-        await handleGenericOperation(db, req, now)
+
+      // index all items into private_data
+      await handleGenericOperation(db, req, now)
+
+      // maintain bespoke indexes for certain namespaces
+      if (
+        namespace ===
+        Namespaces.AppBskyNotificationDefsSubjectActivitySubscription
+      ) {
+        await handleSubjectActivitySubscriptionOperation(db, req, now).catch(
+          (err: unknown) =>
+            httpLogger.warn(
+              { err, namespace },
+              'mock bsync put operation failed',
+            ),
+        )
       }
 
       return {
@@ -182,43 +197,64 @@ const createRoutes = (db: Database) => (router: ConnectRouter) =>
     },
   })
 
-const handleNotificationPreferencesOperation = async (
+const handleSubjectActivitySubscriptionOperation = async (
   db: Database,
   req: PutOperationRequest,
   now: string,
 ) => {
-  const { actorDid, namespace, key, method, payload } = req
-  if (method === Method.CREATE || method === Method.UPDATE) {
+  const { actorDid, key, method, payload } = req
+
+  if (method === Method.DELETE) {
     return db.db
-      .insertInto('private_data')
+      .deleteFrom('activity_subscription')
+      .where('creator', '=', actorDid)
+      .where('key', '=', key)
+      .execute()
+  }
+
+  const parsed = jsonStringToLex(
+    Buffer.from(payload).toString('utf8'),
+  ) as SubjectActivitySubscription
+  const {
+    subject,
+    activitySubscription: { post, reply },
+  } = parsed
+
+  if (method === Method.CREATE) {
+    return db.db
+      .insertInto('activity_subscription')
       .values({
-        actorDid,
-        namespace,
+        creator: actorDid,
+        subjectDid: subject,
         key,
-        payload: Buffer.from(payload).toString('utf8'),
         indexedAt: now,
-        updatedAt: now,
+        post,
+        reply,
       })
-      .onConflict((oc) =>
-        oc.columns(['actorDid', 'namespace', 'key']).doUpdateSet({
-          payload: Buffer.from(payload).toString('utf8'),
-          updatedAt: now,
-        }),
-      )
       .execute()
   }
 
-  return handleGenericOperation(db, req, now)
+  return db.db
+    .updateTable('activity_subscription')
+    .where('creator', '=', actorDid)
+    .where('key', '=', key)
+    .set({
+      indexedAt: now,
+      post,
+      reply,
+    })
+    .execute()
 }
 
+// upsert into or remove from private_data
 const handleGenericOperation = async (
   db: Database,
   req: PutOperationRequest,
   now: string,
 ) => {
   const { actorDid, namespace, key, method, payload } = req
-  if (method === Method.CREATE) {
-    return db.db
+  if (method === Method.CREATE || method === Method.UPDATE) {
+    await db.db
       .insertInto('private_data')
       .values({
         actorDid,
@@ -228,26 +264,21 @@ const handleGenericOperation = async (
         indexedAt: now,
         updatedAt: now,
       })
+      .onConflict((oc) =>
+        oc.columns(['actorDid', 'namespace', 'key']).doUpdateSet({
+          payload: excluded(db.db, 'payload'),
+          updatedAt: excluded(db.db, 'updatedAt'),
+        }),
+      )
       .execute()
-  }
-
-  if (method === Method.UPDATE) {
-    return db.db
-      .updateTable('private_data')
+  } else if (method === Method.DELETE) {
+    await db.db
+      .deleteFrom('private_data')
       .where('actorDid', '=', actorDid)
       .where('namespace', '=', namespace)
       .where('key', '=', key)
-      .set({
-        payload: Buffer.from(payload).toString('utf8'),
-        updatedAt: now,
-      })
       .execute()
+  } else {
+    assert.fail(`unexpected method ${method}`)
   }
-
-  return db.db
-    .deleteFrom('private_data')
-    .where('actorDid', '=', actorDid)
-    .where('namespace', '=', namespace)
-    .where('key', '=', key)
-    .execute()
 }

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

@@ -1,4 +1,5 @@
 import { Kysely } from 'kysely'
+import * as activitySubscription from './tables/activity-subscription'
 import * as actor from './tables/actor'
 import * as actorBlock from './tables/actor-block'
 import * as actorState from './tables/actor-state'
@@ -79,6 +80,7 @@ export type DatabaseSchemaType = duplicateRecord.PartialDB &
   taggedSuggestion.PartialDB &
   quote.PartialDB &
   verification.PartialDB &
-  privateData.PartialDB
+  privateData.PartialDB &
+  activitySubscription.PartialDB
 
 export type DatabaseSchema = Kysely<DatabaseSchemaType>

package/src/data-plane/server/db/migrations/20250611T140649895Z-add-activity-subscription.ts

@@ -0,0 +1,22 @@
+import { Kysely } from 'kysely'
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+  await db.schema
+    .createTable('activity_subscription')
+    .addColumn('creator', 'varchar', (col) => col.notNull())
+    .addColumn('subjectDid', 'varchar', (col) => col.notNull())
+    .addColumn('key', 'varchar', (col) => col.notNull())
+    .addColumn('indexedAt', 'varchar', (col) => col.notNull())
+    .addColumn('post', 'boolean', (col) => col.notNull())
+    .addColumn('reply', 'boolean', (col) => col.notNull())
+    .addPrimaryKeyConstraint('activity_subscription_pkey', ['creator', 'key'])
+    .addUniqueConstraint('activity_subscription_unique_creator_subject_did', [
+      'creator',
+      'subjectDid',
+    ])
+    .execute()
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+  await db.schema.dropTable('activity_subscription').execute()
+}

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

@@ -51,3 +51,4 @@ export * as _20250404T163421487Z from './20250404T163421487Z-verifications'
 export * as _20250526T023712742Z from './20250526T023712742Z-like-repost-via'
 export * as _20250528T221913281Z from './20250528T221913281Z-add-record-tags'
 export * as _20250602T190357447Z from './20250602T190357447Z-add-private-data'
+export * as _20250611T140649895Z from './20250611T140649895Z-add-activity-subscription'

package/src/data-plane/server/db/pagination.ts

@@ -1,4 +1,5 @@
 import { sql } from 'kysely'
+import { ensureValidRecordKey } from '@atproto/syntax'
 import { InvalidRequestError } from '@atproto/xrpc-server'
 import { AnyQb, DbRef } from './util'
 
@@ -294,3 +295,39 @@ export class IsoSortAtKey extends IsoTimeKey<{
     return { primary: result.sortAt }
   }
 }
+
+type KeyResult = { key: string }
+type RkeyLabeledResult = SingleKeyCursor
+
+export class RkeyKey<RkeyResult = KeyResult> extends GenericSingleKey<
+  RkeyResult,
+  RkeyLabeledResult
+> {
+  labelResult(result: RkeyResult): RkeyLabeledResult
+  labelResult<RkeyResult extends KeyResult>(result: RkeyResult) {
+    return { primary: result }
+  }
+  labeledResultToCursor(labeled: RkeyLabeledResult) {
+    return {
+      primary: labeled.primary,
+    }
+  }
+  cursorToLabeledResult(cursor: SingleKeyCursor) {
+    try {
+      ensureValidRecordKey(cursor.primary)
+      return {
+        primary: cursor.primary,
+      }
+    } catch {
+      throw new InvalidRequestError('Malformed cursor')
+    }
+  }
+}
+
+export class StashKeyKey extends RkeyKey<{
+  key: string
+}> {
+  labelResult(result: { key: string }) {
+    return { primary: result.key }
+  }
+}

package/src/data-plane/server/db/tables/activity-subscription.ts

@@ -0,0 +1,12 @@
+export const tableName = 'activity_subscription'
+export interface ActivitySubscription {
+  creator: string
+  subjectDid: string
+  // key from the bsync stash.
+  key: string
+  indexedAt: string
+  post: boolean
+  reply: boolean
+}
+
+export type PartialDB = { [tableName]: ActivitySubscription }

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

@@ -26,6 +26,7 @@ import * as Like from './plugins/like'
 import * as List from './plugins/list'
 import * as ListBlock from './plugins/list-block'
 import * as ListItem from './plugins/list-item'
+import * as NotifDeclaration from './plugins/notif-declaration'
 import * as Post from './plugins/post'
 import * as Postgate from './plugins/post-gate'
 import * as Profile from './plugins/profile'
@@ -52,6 +53,7 @@ export class IndexingService {
     feedGenerator: FeedGenerator.PluginType
     starterPack: StarterPack.PluginType
     labeler: Labeler.PluginType
+    notifDeclaration: NotifDeclaration.PluginType
     chatDeclaration: ChatDeclaration.PluginType
     verification: Verification.PluginType
     status: Status.PluginType
@@ -77,6 +79,7 @@ export class IndexingService {
       feedGenerator: FeedGenerator.makePlugin(this.db, this.background),
       starterPack: StarterPack.makePlugin(this.db, this.background),
       labeler: Labeler.makePlugin(this.db, this.background),
+      notifDeclaration: NotifDeclaration.makePlugin(this.db, this.background),
       chatDeclaration: ChatDeclaration.makePlugin(this.db, this.background),
       verification: Verification.makePlugin(this.db, this.background),
       status: Status.makePlugin(this.db, this.background),

package/src/data-plane/server/indexing/plugins/notif-declaration.ts

@@ -0,0 +1,59 @@
+import { CID } from 'multiformats/cid'
+import { AtUri } from '@atproto/syntax'
+import * as lex from '../../../../lexicon/lexicons'
+import { BackgroundQueue } from '../../background'
+import { Database } from '../../db'
+import { DatabaseSchema } from '../../db/database-schema'
+import { RecordProcessor } from '../processor'
+
+// @NOTE this indexer is a placeholder to ensure it gets indexed in the generic records table
+const lexId = lex.ids.AppBskyNotificationDeclaration
+
+const insertFn = async (
+  _db: DatabaseSchema,
+  uri: AtUri,
+  _cid: CID,
+  _obj: unknown,
+  _timestamp: string,
+): Promise<unknown | null> => {
+  if (uri.rkey !== 'self') return null
+  return true
+}
+
+const findDuplicate = async (): Promise<AtUri | null> => {
+  return null
+}
+
+const notifsForInsert = () => {
+  return []
+}
+
+const deleteFn = async (
+  _db: DatabaseSchema,
+  uri: AtUri,
+): Promise<unknown | null> => {
+  if (uri.rkey !== 'self') return null
+  return true
+}
+
+const notifsForDelete = () => {
+  return { notifs: [], toDelete: [] }
+}
+
+export type PluginType = RecordProcessor<unknown, unknown>
+
+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/activity-subscription.ts

@@ -0,0 +1,83 @@
+import { PlainMessage } from '@bufbuild/protobuf'
+import { ServiceImpl } from '@connectrpc/connect'
+import { keyBy } from '@atproto/common'
+import { Service } from '../../../proto/bsky_connect'
+import {
+  ActivitySubscription,
+  GetActivitySubscriptionsByActorAndSubjectsResponse,
+} from '../../../proto/bsky_pb'
+import { Namespaces } from '../../../stash'
+import { Database } from '../db'
+import { StashKeyKey } from '../db/pagination'
+
+export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
+  async getActivitySubscriptionsByActorAndSubjects(req) {
+    const { actorDid, subjectDids } = req
+    if (subjectDids.length === 0) {
+      return new GetActivitySubscriptionsByActorAndSubjectsResponse({
+        subscriptions: [],
+      })
+    }
+
+    const res = await db.db
+      .selectFrom('activity_subscription')
+      .selectAll()
+      .where('creator', '=', actorDid)
+      .where('subjectDid', 'in', subjectDids)
+      .execute()
+
+    const bySubject = keyBy(res, 'subjectDid')
+    const subscriptions = subjectDids.map(
+      (did): PlainMessage<ActivitySubscription> => {
+        const subject = bySubject.get(did)
+        if (!subject) {
+          return {
+            actorDid,
+            namespace:
+              Namespaces.AppBskyNotificationDefsSubjectActivitySubscription,
+            key: '',
+            post: undefined,
+            reply: undefined,
+            subjectDid: '',
+          }
+        }
+
+        return {
+          actorDid,
+          namespace:
+            Namespaces.AppBskyNotificationDefsSubjectActivitySubscription,
+          key: subject.key,
+          post: subject.post ? {} : undefined,
+          reply: subject.reply ? {} : undefined,
+          subjectDid: subject.subjectDid,
+        }
+      },
+    )
+
+    return {
+      subscriptions,
+    }
+  },
+
+  async getActivitySubscriptionDids(req) {
+    const { actorDid, cursor, limit } = req
+
+    let builder = db.db
+      .selectFrom('activity_subscription')
+      .selectAll()
+      .where('creator', '=', actorDid)
+
+    const { ref } = db.db.dynamic
+    const key = new StashKeyKey(ref('activity_subscription.key'))
+    builder = key.paginate(builder, {
+      cursor,
+      limit,
+    })
+    const res = await builder.execute()
+    const dids = res.map(({ subjectDid }) => subjectDid)
+    return {
+      dids,
+      cursor: key.packFromResult(res),
+    }
+  },
+})