@atproto/bsync 0.0.3 → 0.0.5

package/src/proto/bsync_pb.ts

@@ -1,4 +1,4 @@
-// @generated by protoc-gen-es v1.6.0 with parameter "target=ts,import_extension=.ts"
+// @generated by protoc-gen-es v1.6.0 with parameter "target=ts,import_extension="
 // @generated from file bsync.proto (package bsync, syntax proto3)
 /* eslint-disable */
 // @ts-nocheck
@@ -372,6 +372,323 @@ export class ScanMuteOperationsResponse extends Message<ScanMuteOperationsRespon
   }
 }
 
+/**
+ * @generated from message bsync.NotifOperation
+ */
+export class NotifOperation extends Message<NotifOperation> {
+  /**
+   * @generated from field: string id = 1;
+   */
+  id = ''
+
+  /**
+   * @generated from field: string actor_did = 2;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: optional bool priority = 3;
+   */
+  priority?: boolean
+
+  constructor(data?: PartialMessage<NotifOperation>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.NotifOperation'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'id', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    {
+      no: 3,
+      name: 'priority',
+      kind: 'scalar',
+      T: 8 /* ScalarType.BOOL */,
+      opt: true,
+    },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): NotifOperation {
+    return new NotifOperation().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): NotifOperation {
+    return new NotifOperation().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): NotifOperation {
+    return new NotifOperation().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a: NotifOperation | PlainMessage<NotifOperation> | undefined,
+    b: NotifOperation | PlainMessage<NotifOperation> | undefined,
+  ): boolean {
+    return proto3.util.equals(NotifOperation, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.AddNotifOperationRequest
+ */
+export class AddNotifOperationRequest extends Message<AddNotifOperationRequest> {
+  /**
+   * @generated from field: string actor_did = 1;
+   */
+  actorDid = ''
+
+  /**
+   * @generated from field: optional bool priority = 2;
+   */
+  priority?: boolean
+
+  constructor(data?: PartialMessage<AddNotifOperationRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.AddNotifOperationRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'actor_did', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    {
+      no: 2,
+      name: 'priority',
+      kind: 'scalar',
+      T: 8 /* ScalarType.BOOL */,
+      opt: true,
+    },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): AddNotifOperationRequest {
+    return new AddNotifOperationRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): AddNotifOperationRequest {
+    return new AddNotifOperationRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): AddNotifOperationRequest {
+    return new AddNotifOperationRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | AddNotifOperationRequest
+      | PlainMessage<AddNotifOperationRequest>
+      | undefined,
+    b:
+      | AddNotifOperationRequest
+      | PlainMessage<AddNotifOperationRequest>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(AddNotifOperationRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.AddNotifOperationResponse
+ */
+export class AddNotifOperationResponse extends Message<AddNotifOperationResponse> {
+  /**
+   * @generated from field: bsync.NotifOperation operation = 1;
+   */
+  operation?: NotifOperation
+
+  constructor(data?: PartialMessage<AddNotifOperationResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.AddNotifOperationResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'operation', kind: 'message', T: NotifOperation },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): AddNotifOperationResponse {
+    return new AddNotifOperationResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): AddNotifOperationResponse {
+    return new AddNotifOperationResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): AddNotifOperationResponse {
+    return new AddNotifOperationResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | AddNotifOperationResponse
+      | PlainMessage<AddNotifOperationResponse>
+      | undefined,
+    b:
+      | AddNotifOperationResponse
+      | PlainMessage<AddNotifOperationResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(AddNotifOperationResponse, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.ScanNotifOperationsRequest
+ */
+export class ScanNotifOperationsRequest extends Message<ScanNotifOperationsRequest> {
+  /**
+   * @generated from field: string cursor = 1;
+   */
+  cursor = ''
+
+  /**
+   * @generated from field: int32 limit = 2;
+   */
+  limit = 0
+
+  constructor(data?: PartialMessage<ScanNotifOperationsRequest>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.ScanNotifOperationsRequest'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    { no: 1, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+    { no: 2, name: 'limit', kind: 'scalar', T: 5 /* ScalarType.INT32 */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): ScanNotifOperationsRequest {
+    return new ScanNotifOperationsRequest().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): ScanNotifOperationsRequest {
+    return new ScanNotifOperationsRequest().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): ScanNotifOperationsRequest {
+    return new ScanNotifOperationsRequest().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | ScanNotifOperationsRequest
+      | PlainMessage<ScanNotifOperationsRequest>
+      | undefined,
+    b:
+      | ScanNotifOperationsRequest
+      | PlainMessage<ScanNotifOperationsRequest>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(ScanNotifOperationsRequest, a, b)
+  }
+}
+
+/**
+ * @generated from message bsync.ScanNotifOperationsResponse
+ */
+export class ScanNotifOperationsResponse extends Message<ScanNotifOperationsResponse> {
+  /**
+   * @generated from field: repeated bsync.NotifOperation operations = 1;
+   */
+  operations: NotifOperation[] = []
+
+  /**
+   * @generated from field: string cursor = 2;
+   */
+  cursor = ''
+
+  constructor(data?: PartialMessage<ScanNotifOperationsResponse>) {
+    super()
+    proto3.util.initPartial(data, this)
+  }
+
+  static readonly runtime: typeof proto3 = proto3
+  static readonly typeName = 'bsync.ScanNotifOperationsResponse'
+  static readonly fields: FieldList = proto3.util.newFieldList(() => [
+    {
+      no: 1,
+      name: 'operations',
+      kind: 'message',
+      T: NotifOperation,
+      repeated: true,
+    },
+    { no: 2, name: 'cursor', kind: 'scalar', T: 9 /* ScalarType.STRING */ },
+  ])
+
+  static fromBinary(
+    bytes: Uint8Array,
+    options?: Partial<BinaryReadOptions>,
+  ): ScanNotifOperationsResponse {
+    return new ScanNotifOperationsResponse().fromBinary(bytes, options)
+  }
+
+  static fromJson(
+    jsonValue: JsonValue,
+    options?: Partial<JsonReadOptions>,
+  ): ScanNotifOperationsResponse {
+    return new ScanNotifOperationsResponse().fromJson(jsonValue, options)
+  }
+
+  static fromJsonString(
+    jsonString: string,
+    options?: Partial<JsonReadOptions>,
+  ): ScanNotifOperationsResponse {
+    return new ScanNotifOperationsResponse().fromJsonString(jsonString, options)
+  }
+
+  static equals(
+    a:
+      | ScanNotifOperationsResponse
+      | PlainMessage<ScanNotifOperationsResponse>
+      | undefined,
+    b:
+      | ScanNotifOperationsResponse
+      | PlainMessage<ScanNotifOperationsResponse>
+      | undefined,
+  ): boolean {
+    return proto3.util.equals(ScanNotifOperationsResponse, a, b)
+  }
+}
+
 /**
  * Ping
  *

package/src/routes/add-mute-operation.ts

@@ -1,10 +1,5 @@
 import { sql } from 'kysely'
-import {
-  AtUri,
-  InvalidDidError,
-  ensureValidAtUri,
-  ensureValidDid,
-} from '@atproto/syntax'
+import { AtUri } from '@atproto/syntax'
 import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
 import { Service } from '../proto/bsync_connect'
 import { AddMuteOperationResponse, MuteOperation_Type } from '../proto/bsync_pb'
@@ -12,6 +7,7 @@ import AppContext from '../context'
 import { createMuteOpChannel } from '../db/schema/mute_op'
 import { authWithApiKey } from './auth'
 import Database from '../db'
+import { isValidAtUri, isValidDid } from './util'
 
 export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
   async addMuteOperation(req, handlerCtx) {
@@ -120,9 +116,12 @@ const validMuteOp = (op: MuteOpInfo): MuteOpInfoValid => {
       // all good
     } else if (isValidAtUri(op.subject)) {
       const uri = new AtUri(op.subject)
-      if (uri.collection !== 'app.bsky.graph.list') {
+      if (
+        uri.collection !== 'app.bsky.graph.list' &&
+        uri.collection !== 'app.bsky.feed.post'
+      ) {
         throw new ConnectError(
-          'subject aturis must reference a list record',
+          'subject aturis must reference a list or post record',
           Code.InvalidArgument,
         )
       }
@@ -136,27 +135,6 @@ const validMuteOp = (op: MuteOpInfo): MuteOpInfoValid => {
   return op as MuteOpInfoValid // op.type has been checked
 }
 
-const isValidDid = (did: string) => {
-  try {
-    ensureValidDid(did)
-    return true
-  } catch (err) {
-    if (err instanceof InvalidDidError) {
-      return false
-    }
-    throw err
-  }
-}
-
-const isValidAtUri = (uri: string) => {
-  try {
-    ensureValidAtUri(uri)
-    return true
-  } catch {
-    return false
-  }
-}
-
 type MuteOpInfo = {
   type: MuteOperation_Type
   actorDid: string

package/src/routes/add-notif-operation.ts

@@ -0,0 +1,80 @@
+import { sql } from 'kysely'
+import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../proto/bsync_connect'
+import { AddNotifOperationResponse } from '../proto/bsync_pb'
+import AppContext from '../context'
+import { authWithApiKey } from './auth'
+import Database from '../db'
+import { createNotifOpChannel } from '../db/schema/notif_op'
+import { isValidDid } from './util'
+
+export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
+  async addNotifOperation(req, handlerCtx) {
+    authWithApiKey(ctx, handlerCtx)
+    const { db } = ctx
+    const { actorDid, priority } = req
+    if (!isValidDid(actorDid)) {
+      throw new ConnectError(
+        'actor_did must be a valid did',
+        Code.InvalidArgument,
+      )
+    }
+    const id = await db.transaction(async (txn) => {
+      // create notif op
+      const id = await createNotifOp(txn, actorDid, priority)
+      // update notif state
+      if (priority !== undefined) {
+        await updateNotifItem(txn, id, actorDid, priority)
+      }
+      return id
+    })
+    return new AddNotifOperationResponse({
+      operation: {
+        id: String(id),
+        actorDid,
+        priority,
+      },
+    })
+  },
+})
+
+const createNotifOp = async (
+  db: Database,
+  actorDid: string,
+  priority: boolean | undefined,
+) => {
+  const { ref } = db.db.dynamic
+  const { id } = await db.db
+    .insertInto('notif_op')
+    .values({
+      actorDid,
+      priority,
+    })
+    .returning('id')
+    .executeTakeFirstOrThrow()
+  await sql`notify ${ref(createNotifOpChannel)}`.execute(db.db) // emitted transactionally
+  return id
+}
+
+const updateNotifItem = async (
+  db: Database,
+  fromId: number,
+  actorDid: string,
+  priority: boolean,
+) => {
+  const { ref } = db.db.dynamic
+  await db.db
+    .insertInto('notif_item')
+    .values({
+      actorDid,
+      priority,
+      fromId,
+    })
+    .onConflict((oc) =>
+      oc.column('actorDid').doUpdateSet({
+        priority: sql`${ref('excluded.priority')}`,
+        fromId: sql`${ref('excluded.fromId')}`,
+      }),
+    )
+    .execute()
+}

package/src/routes/index.ts

@@ -4,11 +4,15 @@ import { Service } from '../proto/bsync_connect'
 import AppContext from '../context'
 import addMuteOperation from './add-mute-operation'
 import scanMuteOperations from './scan-mute-operations'
+import addNotifOperation from './add-notif-operation'
+import scanNotifOperations from './scan-notif-operations'
 
 export default (ctx: AppContext) => (router: ConnectRouter) => {
   return router.service(Service, {
     ...addMuteOperation(ctx),
     ...scanMuteOperations(ctx),
+    ...addNotifOperation(ctx),
+    ...scanNotifOperations(ctx),
     async ping() {
       const { db } = ctx
       await sql`select 1`.execute(db.db)

package/src/routes/scan-mute-operations.ts

@@ -1,10 +1,11 @@
 import { once } from 'node:events'
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
+import { ServiceImpl } from '@connectrpc/connect'
 import { Service } from '../proto/bsync_connect'
 import { ScanMuteOperationsResponse } from '../proto/bsync_pb'
 import AppContext from '../context'
 import { createMuteOpChannel } from '../db/schema/mute_op'
 import { authWithApiKey } from './auth'
+import { combineSignals, validCursor } from './util'
 
 export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
   async scanMuteOperations(req, handlerCtx) {
@@ -62,27 +63,3 @@ export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
     })
   },
 })
-
-const validCursor = (cursor: string): number | null => {
-  if (cursor === '') return null
-  const int = parseInt(cursor, 10)
-  if (isNaN(int) || int < 0) {
-    throw new ConnectError('invalid cursor', Code.InvalidArgument)
-  }
-  return int
-}
-
-const combineSignals = (a: AbortSignal, b: AbortSignal) => {
-  const controller = new AbortController()
-  for (const signal of [a, b]) {
-    if (signal.aborted) {
-      controller.abort()
-      return signal
-    }
-    signal.addEventListener('abort', () => controller.abort(signal.reason), {
-      // @ts-ignore https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68625
-      signal: controller.signal,
-    })
-  }
-  return controller.signal
-}

package/src/routes/scan-notif-operations.ts

@@ -0,0 +1,64 @@
+import { once } from 'node:events'
+import { ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../proto/bsync_connect'
+import { ScanNotifOperationsResponse } from '../proto/bsync_pb'
+import AppContext from '../context'
+import { authWithApiKey } from './auth'
+import { combineSignals, validCursor } from './util'
+import { createNotifOpChannel } from '../db/schema/notif_op'
+
+export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
+  async scanNotifOperations(req, handlerCtx) {
+    authWithApiKey(ctx, handlerCtx)
+    const { db, events } = ctx
+    const limit = req.limit || 1000
+    const cursor = validCursor(req.cursor)
+    const nextNotifOpPromise = once(events, createNotifOpChannel, {
+      signal: combineSignals(
+        ctx.shutdown,
+        AbortSignal.timeout(ctx.cfg.service.longPollTimeoutMs),
+      ),
+    })
+    nextNotifOpPromise.catch(() => null) // ensure timeout is always handled
+
+    const nextNotifOpPageQb = db.db
+      .selectFrom('notif_op')
+      .selectAll()
+      .where('id', '>', cursor ?? -1)
+      .orderBy('id', 'asc')
+      .limit(limit)
+
+    let ops = await nextNotifOpPageQb.execute()
+
+    if (!ops.length) {
+      // if there were no ops on the page, wait for an event then try again.
+      try {
+        await nextNotifOpPromise
+      } catch (err) {
+        ctx.shutdown.throwIfAborted()
+        return new ScanNotifOperationsResponse({
+          operations: [],
+          cursor: req.cursor,
+        })
+      }
+      ops = await nextNotifOpPageQb.execute()
+      if (!ops.length) {
+        return new ScanNotifOperationsResponse({
+          operations: [],
+          cursor: req.cursor,
+        })
+      }
+    }
+
+    const lastOp = ops[ops.length - 1]
+
+    return new ScanNotifOperationsResponse({
+      operations: ops.map((op) => ({
+        id: op.id.toString(),
+        actorDid: op.actorDid,
+        priority: op.priority ?? undefined,
+      })),
+      cursor: lastOp.id.toString(),
+    })
+  },
+})

package/src/routes/util.ts

@@ -0,0 +1,51 @@
+import { Code, ConnectError } from '@connectrpc/connect'
+import {
+  InvalidDidError,
+  ensureValidAtUri,
+  ensureValidDid,
+} from '@atproto/syntax'
+
+export const validCursor = (cursor: string): number | null => {
+  if (cursor === '') return null
+  const int = parseInt(cursor, 10)
+  if (isNaN(int) || int < 0) {
+    throw new ConnectError('invalid cursor', Code.InvalidArgument)
+  }
+  return int
+}
+
+export const combineSignals = (a: AbortSignal, b: AbortSignal) => {
+  const controller = new AbortController()
+  for (const signal of [a, b]) {
+    if (signal.aborted) {
+      controller.abort()
+      return signal
+    }
+    signal.addEventListener('abort', () => controller.abort(signal.reason), {
+      // @ts-ignore https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68625
+      signal: controller.signal,
+    })
+  }
+  return controller.signal
+}
+
+export const isValidDid = (did: string) => {
+  try {
+    ensureValidDid(did)
+    return true
+  } catch (err) {
+    if (err instanceof InvalidDidError) {
+      return false
+    }
+    throw err
+  }
+}
+
+export const isValidAtUri = (uri: string) => {
+  try {
+    ensureValidAtUri(uri)
+    return true
+  } catch {
+    return false
+  }
+}

package/tests/mutes.test.ts

@@ -1,4 +1,5 @@
 import { wait } from '@atproto/common'
+import getPort from 'get-port'
 import { Code, ConnectError } from '@connectrpc/connect'
 import {
   BsyncClient,
@@ -17,6 +18,7 @@ describe('mutes', () => {
   beforeAll(async () => {
     bsync = await BsyncService.create(
       envToCfg({
+        port: await getPort(),
         dbUrl: process.env.DB_POSTGRES_URL,
         dbSchema: 'bsync_mutes',
         apiKeys: ['key-1'],