@atproto/bsky 0.0.25 → 0.0.26

package/src/proto/courier_pb.ts

@@ -0,0 +1,473 @@
+// @generated by protoc-gen-es v1.6.0 with parameter "target=ts,import_extension=.ts"
+// @generated from file courier.proto (package courier, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+
+import type {
+  BinaryReadOptions,
+  FieldList,
+  JsonReadOptions,
+  JsonValue,
+  PartialMessage,
+  PlainMessage,
+} from '@bufbuild/protobuf'
+import { Message, proto3, Struct, Timestamp } from '@bufbuild/protobuf'
+
+/**
+ * @generated from enum courier.AppPlatform
+ */
+export enum AppPlatform {
+  /**
+   * @generated from enum value: APP_PLATFORM_UNSPECIFIED = 0;
+   */
+  UNSPECIFIED = 0,
+
+  /**
+   * @generated from enum value: APP_PLATFORM_IOS = 1;
+   */
+  IOS = 1,
+
+  /**
+   * @generated from enum value: APP_PLATFORM_ANDROID = 2;
+   */
+  ANDROID = 2,
+
+  /**
+   * @generated from enum value: APP_PLATFORM_WEB = 3;
+   */
+  WEB = 3,
+}
+// Retrieve enum metadata with: proto3.getEnumType(AppPlatform)
+proto3.util.setEnumType(AppPlatform, 'courier.AppPlatform', [
+  { no: 0, name: 'APP_PLATFORM_UNSPECIFIED' },
+  { no: 1, name: 'APP_PLATFORM_IOS' },
+  { no: 2, name: 'APP_PLATFORM_ANDROID' },
+  { no: 3, name: 'APP_PLATFORM_WEB' },
+])
+
+/**
+ * Ping
+ *
+ * @generated from message courier.PingRequest
+ */
+export class PingRequest extends Message<PingRequest> {
+  constructor(data?: PartialMessage<PingRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.PingRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PingRequest {
+    return new PingRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PingRequest {
+    return new PingRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PingRequest {
+    return new PingRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: PingRequest | PlainMessage<PingRequest> | undefined,
+    b: PingRequest | PlainMessage<PingRequest> | undefined,
+  ): boolean {
+    return proto3.util.equals(PingRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message courier.PingResponse
+ */
+export class PingResponse extends Message<PingResponse> {
+  constructor(data?: PartialMessage<PingResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.PingResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PingResponse {
+    return new PingResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PingResponse {
+    return new PingResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PingResponse {
+    return new PingResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: PingResponse | PlainMessage<PingResponse> | undefined,
+    b: PingResponse | PlainMessage<PingResponse> | undefined,
+  ): boolean {
+    return proto3.util.equals(PingResponse, a, b)
+  }
+}
+
+/**
+ * @generated from message courier.Notification
+ */
+export class Notification extends Message<Notification> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = ''
+
+  /**
+   * @generated from field: string recipient_did = 2;
+   */
+  recipientDid = ''
+
+  /**
+   * @generated from field: string title = 3;
+   */
+  title = ''
+
+  /**
+   * @generated from field: string message = 4;
+   */
+  message = ''
+
+  /**
+   * @generated from field: string collapse_key = 5;
+   */
+  collapseKey = ''
+
+  /**
+   * @generated from field: bool always_deliver = 6;
+   */
+  alwaysDeliver = false
+
+  /**
+   * @generated from field: google.protobuf.Timestamp timestamp = 7;
+   */
+  timestamp?: Timestamp
+
+  /**
+   * @generated from field: google.protobuf.Struct additional = 8;
+   */
+  additional?: Struct
+
+  constructor(data?: PartialMessage<Notification>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.Notification'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    {
+      no: 2,
+      name: 'recipient_did',
+      kind: 'scalar',
+      T: 9 /* ScalarType.STRING */,
+    },
+    { no: 3, name: 'title', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 4, name: 'message', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    {
+      no: 5,
+      name: 'collapse_key',
+      kind: 'scalar',
+      T: 9 /* ScalarType.STRING */,
+    },
+    {
+      no: 6,
+      name: 'always_deliver',
+      kind: 'scalar',
+      T: 8 /* ScalarType.BOOL */,
+    },
+    { no: 7, name: 'timestamp', kind: 'message', T: Timestamp },
+    { no: 8, name: 'additional', kind: 'message', T: Struct },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): Notification {
+    return new Notification().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): Notification {
+    return new Notification().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): Notification {
+    return new Notification().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: Notification | PlainMessage<Notification> | undefined,
+    b: Notification | PlainMessage<Notification> | undefined,
+  ): boolean {
+    return proto3.util.equals(Notification, a, b)
+  }
+}
+
+/**
+ * @generated from message courier.PushNotificationsRequest
+ */
+export class PushNotificationsRequest extends Message<PushNotificationsRequest> {
+  /**
+   * @generated from field: repeated courier.Notification notifications = 1;
+   */
+  notifications: Notification[] = []
+
+  constructor(data?: PartialMessage<PushNotificationsRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.PushNotificationsRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: 'notifications',
+      kind: 'message',
+      T: Notification,
+      repeated: true,
+    },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PushNotificationsRequest {
+    return new PushNotificationsRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PushNotificationsRequest {
+    return new PushNotificationsRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PushNotificationsRequest {
+    return new PushNotificationsRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | PushNotificationsRequest
+      | PlainMessage<PushNotificationsRequest>
+      | undefined,
+    b:
+      | PushNotificationsRequest
+      | PlainMessage<PushNotificationsRequest>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(PushNotificationsRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message courier.PushNotificationsResponse
+ */
+export class PushNotificationsResponse extends Message<PushNotificationsResponse> {
+  constructor(data?: PartialMessage<PushNotificationsResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.PushNotificationsResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): PushNotificationsResponse {
+    return new PushNotificationsResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): PushNotificationsResponse {
+    return new PushNotificationsResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): PushNotificationsResponse {
+    return new PushNotificationsResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | PushNotificationsResponse
+      | PlainMessage<PushNotificationsResponse>
+      | undefined,
+    b:
+      | PushNotificationsResponse
+      | PlainMessage<PushNotificationsResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(PushNotificationsResponse, a, b)
+  }
+}
+
+/**
+ * @generated from message courier.RegisterDeviceTokenRequest
+ */
+export class RegisterDeviceTokenRequest extends Message<RegisterDeviceTokenRequest> {
+  /**
+   * @generated from field: string did = 1;
+   */
+  did = ''
+
+  /**
+   * @generated from field: string token = 2;
+   */
+  token = ''
+
+  /**
+   * @generated from field: string app_id = 3;
+   */
+  appId = ''
+
+  /**
+   * @generated from field: courier.AppPlatform platform = 4;
+   */
+  platform = AppPlatform.UNSPECIFIED
+
+  constructor(data?: PartialMessage<RegisterDeviceTokenRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.RegisterDeviceTokenRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'token', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 3, name: 'app_id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    {
+      no: 4,
+      name: 'platform',
+      kind: 'enum',
+      T: proto3.getEnumType(AppPlatform),
+    },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): RegisterDeviceTokenRequest {
+    return new RegisterDeviceTokenRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): RegisterDeviceTokenRequest {
+    return new RegisterDeviceTokenRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): RegisterDeviceTokenRequest {
+    return new RegisterDeviceTokenRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | RegisterDeviceTokenRequest
+      | PlainMessage<RegisterDeviceTokenRequest>
+      | undefined,
+    b:
+      | RegisterDeviceTokenRequest
+      | PlainMessage<RegisterDeviceTokenRequest>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(RegisterDeviceTokenRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message courier.RegisterDeviceTokenResponse
+ */
+export class RegisterDeviceTokenResponse extends Message<RegisterDeviceTokenResponse> {
+  constructor(data?: PartialMessage<RegisterDeviceTokenResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'courier.RegisterDeviceTokenResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): RegisterDeviceTokenResponse {
+    return new RegisterDeviceTokenResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): RegisterDeviceTokenResponse {
+    return new RegisterDeviceTokenResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): RegisterDeviceTokenResponse {
+    return new RegisterDeviceTokenResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | RegisterDeviceTokenResponse
+      | PlainMessage<RegisterDeviceTokenResponse>
+      | undefined,
+    b:
+      | RegisterDeviceTokenResponse
+      | PlainMessage<RegisterDeviceTokenResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(RegisterDeviceTokenResponse, a, b)
+  }
+}

package/src/services/actor/index.ts

@@ -12,6 +12,7 @@ import { GraphService } from '../graph'
 import { LabelService } from '../label'
 import { AtUri } from '@atproto/syntax'
 import { ids } from '../../lexicon/lexicons'
+import { Platform } from '../../notifications'
 
 export * from './types'
 
@@ -21,8 +22,8 @@ export class ActorService {
   constructor(
     public db: Database,
     public imgUriBuilder: ImageUriBuilder,
-    private graph: FromDb<GraphService>,
-    private label: FromDb<LabelService>,
+    graph: FromDb<GraphService>,
+    label: FromDb<LabelService>,
   ) {
     this.views = new ActorViews(this.db, this.imgUriBuilder, graph, label)
   }
@@ -214,6 +215,20 @@ export class ActorService {
       }
     }
   }
+
+  async registerPushDeviceToken(
+    did: string,
+    token: string,
+    platform: Platform,
+    appId: string,
+  ) {
+    await this.db
+      .asPrimary()
+      .db.insertInto('notification_push_token')
+      .values({ did, token, platform, appId })
+      .onConflict((oc) => oc.doNothing())
+      .execute()
+  }
 }
 
 type ActorResult = Actor

package/src/services/indexing/processor.ts

@@ -257,7 +257,7 @@ export class RecordProcessor<T, S> {
         const notifServer = this.notifServer
         sendOnCommit.push(async () => {
           try {
-            const preparedNotifs = await notifServer.prepareNotifsToSend(chunk)
+            const preparedNotifs = await notifServer.prepareNotifications(chunk)
             await notifServer.processNotifications(preparedNotifs)
           } catch (error) {
             dbLogger.error({ error }, 'error sending push notifications')

package/src/util/retry.ts

@@ -1,6 +1,7 @@
 import { AxiosError } from 'axios'
 import { XRPCError, ResponseType } from '@atproto/xrpc'
 import { RetryOptions, retry } from '@atproto/common'
+import { Code, ConnectError } from '@connectrpc/connect'
 
 export async function retryHttp<T>(
   fn: () => Promise<T>,
@@ -24,3 +25,14 @@ export function retryableHttp(err: unknown) {
 const retryableHttpStatusCodes = new Set([
   408, 425, 429, 500, 502, 503, 504, 522, 524,
 ])
+
+export async function retryConnect<T>(
+  fn: () => Promise<T>,
+  opts: RetryOptions = {},
+): Promise<T> {
+  return retry(fn, { retryable: retryableConnect, ...opts })
+}
+
+export function retryableConnect(err: unknown) {
+  return err instanceof ConnectError && err.code === Code.Unavailable
+}

package/tests/notification-server.test.ts

@@ -1,14 +1,18 @@
 import AtpAgent, { AtUri } from '@atproto/api'
 import { TestNetwork, SeedClient, basicSeed } from '@atproto/dev-env'
-import { NotificationServer } from '../src/notifications'
+import {
+  CourierNotificationServer,
+  GorushNotificationServer,
+} from '../src/notifications'
 import { Database } from '../src'
+import { createCourierClient } from '../src/courier'
 
 describe('notification server', () => {
   let network: TestNetwork
   let agent: AtpAgent
   let pdsAgent: AtpAgent
   let sc: SeedClient
-  let notifServer: NotificationServer
+  let notifServer: GorushNotificationServer
 
   // account dids, for convenience
   let alice: string
@@ -24,14 +28,17 @@ describe('notification server', () => {
     await network.processAll()
     await network.bsky.processAll()
     alice = sc.dids.alice
-    notifServer = network.bsky.ctx.notifServer
+    notifServer = new GorushNotificationServer(
+      network.bsky.ctx.db.getPrimary(),
+      'http://mock',
+    )
   })
 
   afterAll(async () => {
     await network.close()
   })
 
-  describe('registerPushNotification', () => {
+  describe('registerPush', () => {
     it('registers push notification token and device.', async () => {
       const res = await agent.api.app.bsky.notification.registerPush(
         {
@@ -95,19 +102,14 @@ describe('notification server', () => {
   })
 
   describe('NotificationServer', () => {
-    it('gets user tokens from db', async () => {
-      const tokens = await notifServer.getTokensByDid([alice])
-      expect(tokens[alice][0].token).toEqual('123')
-    })
-
     it('gets notification display attributes: title and body', async () => {
       const db = network.bsky.ctx.db.getPrimary()
       const notif = await getLikeNotification(db, alice)
       if (!notif) throw new Error('no notification found')
-      const attrs = await notifServer.getNotificationDisplayAttributes([notif])
-      if (!attrs.length)
+      const views = await notifServer.getNotificationViews([notif])
+      if (!views.length)
         throw new Error('no notification display attributes found')
-      expect(attrs[0].title).toEqual('bobby liked your post')
+      expect(views[0].title).toEqual('bobby liked your post')
     })
 
     it('filters notifications that violate blocks', async () => {
@@ -126,11 +128,11 @@ describe('notification server', () => {
         did: notif.author,
         author: notif.did,
       }
-      const attrs = await notifServer.getNotificationDisplayAttributes([
+      const views = await notifServer.getNotificationViews([
         notif,
         flippedNotif,
       ])
-      expect(attrs.length).toBe(0)
+      expect(views.length).toBe(0)
       const uri = new AtUri(blockRef.uri)
       await pdsAgent.api.app.bsky.graph.block.delete(
         { repo: alice, rkey: uri.rkey },
@@ -147,8 +149,8 @@ describe('notification server', () => {
         { actor: notif.author },
         { headers: sc.getHeaders(alice), encoding: 'application/json' },
       )
-      const attrs = await notifServer.getNotificationDisplayAttributes([notif])
-      expect(attrs.length).toBe(0)
+      const views = await notifServer.getNotificationViews([notif])
+      expect(views.length).toBe(0)
       await pdsAgent.api.app.bsky.graph.unmuteActor(
         { actor: notif.author },
         { headers: sc.getHeaders(alice), encoding: 'application/json' },
@@ -182,13 +184,20 @@ describe('notification server', () => {
         { list: listRef.uri },
         { headers: sc.getHeaders(alice), encoding: 'application/json' },
       )
-      const attrs = await notifServer.getNotificationDisplayAttributes([notif])
-      expect(attrs.length).toBe(0)
+      const views = await notifServer.getNotificationViews([notif])
+      expect(views.length).toBe(0)
       await pdsAgent.api.app.bsky.graph.unmuteActorList(
         { list: listRef.uri },
         { headers: sc.getHeaders(alice), encoding: 'application/json' },
       )
     })
+  })
+
+  describe('GorushNotificationServer', () => {
+    it('gets user tokens from db', async () => {
+      const tokens = await notifServer.getTokensByDid([alice])
+      expect(tokens[alice][0].token).toEqual('123')
+    })
 
     it('prepares notification to be sent', async () => {
       const db = network.bsky.ctx.db.getPrimary()
@@ -198,7 +207,7 @@ describe('notification server', () => {
         notif,
         notif /* second one will get dropped by rate limit */,
       ]
-      const prepared = await notifServer.prepareNotifsToSend(notifAsArray)
+      const prepared = await notifServer.prepareNotifications(notifAsArray)
       expect(prepared).toEqual([
         {
           collapse_id: 'like',
@@ -218,6 +227,37 @@ describe('notification server', () => {
     })
   })
 
+  describe('CourierNotificationServer', () => {
+    it('prepares notification to be sent', async () => {
+      const db = network.bsky.ctx.db.getPrimary()
+      const notif = await getLikeNotification(db, alice)
+      if (!notif) throw new Error('no notification found')
+      const courierNotifServer = new CourierNotificationServer(
+        db,
+        createCourierClient({ baseUrl: 'http://mock', httpVersion: '2' }),
+      )
+      const prepared = await courierNotifServer.prepareNotifications([notif])
+      expect(prepared[0]?.id).toBeTruthy()
+      expect(prepared.map((p) => p.toJson())).toEqual([
+        {
+          id: prepared[0].id, // already ensured it exists
+          recipientDid: notif.did,
+          title: 'bobby liked your post',
+          message: 'again',
+          collapseKey: 'like',
+          timestamp: notif.sortAt,
+          // this is missing, appears to be a quirk of toJson()
+          // alwaysDeliver: false,
+          additional: {
+            reason: notif.reason,
+            uri: notif.recordUri,
+            subject: notif.reasonSubject,
+          },
+        },
+      ])
+    })
+  })
+
   async function getLikeNotification(db: Database, did: string) {
     return await db.db
       .selectFrom('notification')