@atproto/bsync 0.0.0

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

@@ -0,0 +1,173 @@
+import { sql } from 'kysely'
+import {
+  AtUri,
+  InvalidDidError,
+  ensureValidAtUri,
+  ensureValidDid,
+} from '@atproto/syntax'
+import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../gen/bsync_connect'
+import { AddMuteOperationResponse, MuteOperation_Type } from '../gen/bsync_pb'
+import AppContext from '../context'
+import { createMuteOpChannel } from '../db/schema/mute_op'
+import { authWithApiKey } from './auth'
+import Database from '../db'
+
+export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
+  async addMuteOperation(req, handlerCtx) {
+    authWithApiKey(ctx, handlerCtx)
+    const { db } = ctx
+    const op = validMuteOp(req)
+    const id = await db.transaction(async (txn) => {
+      // create mute op
+      const id = await createMuteOp(txn, op)
+      // update mute state
+      if (op.type === MuteOperation_Type.ADD) {
+        await addMuteItem(txn, id, op)
+      } else if (op.type === MuteOperation_Type.REMOVE) {
+        await removeMuteItem(txn, op)
+      } else if (op.type === MuteOperation_Type.CLEAR) {
+        await clearMuteItems(txn, op)
+      } else {
+        const exhaustiveCheck: never = op.type
+        throw new Error(`unreachable: ${exhaustiveCheck}`)
+      }
+      return id
+    })
+    return new AddMuteOperationResponse({
+      operation: {
+        id: String(id),
+        type: op.type,
+        actorDid: op.actorDid,
+        subject: op.subject,
+      },
+    })
+  },
+})
+
+const createMuteOp = async (db: Database, op: MuteOpInfo) => {
+  const { ref } = db.db.dynamic
+  const { id } = await db.db
+    .insertInto('mute_op')
+    .values({
+      type: op.type,
+      actorDid: op.actorDid,
+      subject: op.subject,
+    })
+    .returning('id')
+    .executeTakeFirstOrThrow()
+  await sql`notify ${ref(createMuteOpChannel)}`.execute(db.db) // emitted transactionally
+  return id
+}
+
+const addMuteItem = async (db: Database, fromId: number, op: MuteOpInfo) => {
+  const { ref } = db.db.dynamic
+  await db.db
+    .insertInto('mute_item')
+    .values({
+      actorDid: op.actorDid,
+      subject: op.subject,
+      fromId,
+    })
+    .onConflict((oc) =>
+      oc
+        .constraint('mute_item_pkey')
+        .doUpdateSet({ fromId: sql`${ref('excluded.fromId')}` }),
+    )
+    .execute()
+}
+
+const removeMuteItem = async (db: Database, op: MuteOpInfo) => {
+  await db.db
+    .deleteFrom('mute_item')
+    .where('actorDid', '=', op.actorDid)
+    .where('subject', '=', op.subject)
+    .execute()
+}
+
+const clearMuteItems = async (db: Database, op: MuteOpInfo) => {
+  await db.db
+    .deleteFrom('mute_item')
+    .where('actorDid', '=', op.actorDid)
+    .execute()
+}
+
+const validMuteOp = (op: MuteOpInfo): MuteOpInfoValid => {
+  if (!Object.values(MuteOperation_Type).includes(op.type)) {
+    throw new ConnectError('bad mute operation type', Code.InvalidArgument)
+  }
+  if (op.type === MuteOperation_Type.UNSPECIFIED) {
+    throw new ConnectError(
+      'unspecified mute operation type',
+      Code.InvalidArgument,
+    )
+  }
+  if (!isValidDid(op.actorDid)) {
+    throw new ConnectError(
+      'actor_did must be a valid did',
+      Code.InvalidArgument,
+    )
+  }
+  if (op.type === MuteOperation_Type.CLEAR) {
+    if (op.subject !== '') {
+      throw new ConnectError(
+        'subject must not be set on a clear op',
+        Code.InvalidArgument,
+      )
+    }
+  } else {
+    if (isValidDid(op.subject)) {
+      // all good
+    } else if (isValidAtUri(op.subject)) {
+      const uri = new AtUri(op.subject)
+      if (uri.collection !== 'app.bsky.graph.list') {
+        throw new ConnectError(
+          'subject aturis must reference a list record',
+          Code.InvalidArgument,
+        )
+      }
+    } else {
+      throw new ConnectError(
+        'subject must be a did or aturi on add or remove op',
+        Code.InvalidArgument,
+      )
+    }
+  }
+  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
+  subject: string
+}
+
+type MuteOpInfoValid = {
+  type:
+    | MuteOperation_Type.ADD
+    | MuteOperation_Type.REMOVE
+    | MuteOperation_Type.CLEAR
+  actorDid: string
+  subject: string
+}

package/src/routes/auth.ts

@@ -0,0 +1,15 @@
+import { Code, ConnectError, HandlerContext } from '@connectrpc/connect'
+import AppContext from '../context'
+
+const BEARER = 'Bearer '
+
+export const authWithApiKey = (ctx: AppContext, handlerCtx: HandlerContext) => {
+  const authorization = handlerCtx.requestHeader.get('authorization')
+  if (!authorization?.startsWith(BEARER)) {
+    throw new ConnectError('missing auth', Code.Unauthenticated)
+  }
+  const key = authorization.slice(BEARER.length)
+  if (!ctx.cfg.auth.apiKeys.has(key)) {
+    throw new ConnectError('invalid api key', Code.Unauthenticated)
+  }
+}

package/src/routes/index.ts

@@ -0,0 +1,18 @@
+import { sql } from 'kysely'
+import { ConnectRouter } from '@connectrpc/connect'
+import { Service } from '../gen/bsync_connect'
+import AppContext from '../context'
+import addMuteOperation from './add-mute-operation'
+import scanMuteOperations from './scan-mute-operations'
+
+export default (ctx: AppContext) => (router: ConnectRouter) => {
+  return router.service(Service, {
+    ...addMuteOperation(ctx),
+    ...scanMuteOperations(ctx),
+    async ping() {
+      const { db } = ctx
+      await sql`select 1`.execute(db.db)
+      return {}
+    },
+  })
+}

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

@@ -0,0 +1,69 @@
+import { once } from 'node:events'
+import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
+import { Service } from '../gen/bsync_connect'
+import { ScanMuteOperationsResponse } from '../gen/bsync_pb'
+import AppContext from '../context'
+import { createMuteOpChannel } from '../db/schema/mute_op'
+import { authWithApiKey } from './auth'
+
+export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
+  async scanMuteOperations(req, handlerCtx) {
+    authWithApiKey(ctx, handlerCtx)
+    const { db, events } = ctx
+    const limit = req.limit || 1000
+    const cursor = validCursor(req.cursor)
+    const nextMuteOpPromise = once(events, createMuteOpChannel, {
+      signal: AbortSignal.timeout(ctx.cfg.service.longPollTimeoutMs),
+    })
+    nextMuteOpPromise.catch(() => null) // ensure timeout is always handled
+
+    const nextMuteOpPageQb = db.db
+      .selectFrom('mute_op')
+      .selectAll()
+      .where('id', '>', cursor ?? -1)
+      .orderBy('id', 'asc')
+      .limit(limit)
+
+    let ops = await nextMuteOpPageQb.execute()
+
+    if (!ops.length) {
+      // if there were no ops on the page, wait for an event then try again.
+      try {
+        await nextMuteOpPromise
+      } catch (err) {
+        return new ScanMuteOperationsResponse({
+          operations: [],
+          cursor: req.cursor,
+        })
+      }
+      ops = await nextMuteOpPageQb.execute()
+      if (!ops.length) {
+        return new ScanMuteOperationsResponse({
+          operations: [],
+          cursor: req.cursor,
+        })
+      }
+    }
+
+    const lastOp = ops[ops.length - 1]
+
+    return new ScanMuteOperationsResponse({
+      operations: ops.map((op) => ({
+        id: op.id.toString(),
+        type: op.type,
+        actorDid: op.actorDid,
+        subject: op.subject,
+      })),
+      cursor: lastOp.id.toString(),
+    })
+  },
+})
+
+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
+}

package/tests/mutes.test.ts

@@ -0,0 +1,350 @@
+import { wait } from '@atproto/common'
+import { Code, ConnectError } from '@connectrpc/connect'
+import {
+  BsyncClient,
+  BsyncService,
+  Database,
+  authWithApiKey,
+  createClient,
+  envToCfg,
+} from '../src'
+import { MuteOperation, MuteOperation_Type } from '../src/gen/bsync_pb'
+
+describe('mutes', () => {
+  let bsync: BsyncService
+  let client: BsyncClient
+
+  beforeAll(async () => {
+    bsync = await BsyncService.create(
+      envToCfg({
+        dbUrl: process.env.DB_POSTGRES_URL,
+        dbSchema: 'bsync_mutes',
+        apiKeys: ['key-1'],
+        longPollTimeoutMs: 500,
+      }),
+    )
+    await bsync.ctx.db.migrateToLatestOrThrow()
+    await bsync.start()
+    client = createClient({
+      httpVersion: '1.1',
+      baseUrl: `http://localhost:${bsync.ctx.cfg.service.port}`,
+      interceptors: [authWithApiKey('key-1')],
+    })
+  })
+
+  afterAll(async () => {
+    await bsync.destroy()
+  })
+
+  beforeEach(async () => {
+    await clearMutes(bsync.ctx.db)
+  })
+
+  describe('addMuteOperation', () => {
+    it('adds mute operations to add mutes.', async () => {
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:b',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:c',
+      })
+      // dupe has no effect
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:c',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:b',
+        subject: 'did:example:c',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:c',
+        subject: 'at://did:example:d/app.bsky.graph.list/rkey1',
+      })
+      expect(await dumpMuteState(bsync.ctx.db)).toEqual({
+        'did:example:a': ['did:example:b', 'did:example:c'],
+        'did:example:b': ['did:example:c'],
+        'did:example:c': ['at://did:example:d/app.bsky.graph.list/rkey1'],
+      })
+    })
+
+    it('adds mute operations to remove mutes.', async () => {
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:b',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:c',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:b',
+        subject: 'did:example:c',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.REMOVE,
+        actorDid: 'did:example:a',
+        subject: 'did:example:c',
+      })
+      // removes nothing
+      await client.addMuteOperation({
+        type: MuteOperation_Type.REMOVE,
+        actorDid: 'did:example:b',
+        subject: 'did:example:d',
+      })
+      expect(await dumpMuteState(bsync.ctx.db)).toEqual({
+        'did:example:a': ['did:example:b'],
+        'did:example:b': ['did:example:c'],
+      })
+    })
+
+    it('adds mute operations to clear mutes.', async () => {
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:b',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:c',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:b',
+        subject: 'did:example:c',
+      })
+      await client.addMuteOperation({
+        type: MuteOperation_Type.CLEAR,
+        actorDid: 'did:example:a',
+      })
+      expect(await dumpMuteState(bsync.ctx.db)).toEqual({
+        'did:example:b': ['did:example:c'],
+      })
+    })
+
+    it('fails on bad inputs', async () => {
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.ADD,
+          actorDid: 'did:example:a',
+          subject: 'invalid',
+        }),
+      ).rejects.toEqual(
+        new ConnectError(
+          'subject must be a did or aturi on add or remove op',
+          Code.InvalidArgument,
+        ),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.ADD,
+          actorDid: 'did:example:a',
+        }),
+      ).rejects.toEqual(
+        new ConnectError(
+          'subject must be a did or aturi on add or remove op',
+          Code.InvalidArgument,
+        ),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.ADD,
+          actorDid: 'did:example:a',
+          subject: 'at://did:example:b/bad.collection/rkey1',
+        }),
+      ).rejects.toEqual(
+        new ConnectError(
+          'subject must be a did or aturi on add or remove op',
+          Code.InvalidArgument,
+        ),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.ADD,
+          actorDid: 'invalid',
+          subject: 'did:example:b',
+        }),
+      ).rejects.toEqual(
+        new ConnectError('actor_did must be a valid did', Code.InvalidArgument),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.REMOVE,
+          actorDid: 'did:example:a',
+          subject: 'invalid',
+        }),
+      ).rejects.toEqual(
+        new ConnectError(
+          'subject must be a did or aturi on add or remove op',
+          Code.InvalidArgument,
+        ),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.CLEAR,
+          actorDid: 'did:example:a',
+          subject: 'did:example:b',
+        }),
+      ).rejects.toEqual(
+        new ConnectError(
+          'subject must not be set on a clear op',
+          Code.InvalidArgument,
+        ),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: MuteOperation_Type.CLEAR,
+          actorDid: 'invalid',
+        }),
+      ).rejects.toEqual(
+        new ConnectError('actor_did must be a valid did', Code.InvalidArgument),
+      )
+      await expect(
+        client.addMuteOperation({
+          type: 100 as any,
+          actorDid: 'did:example:a',
+          subject: 'did:example:b',
+        }),
+      ).rejects.toEqual(
+        new ConnectError('bad mute operation type', Code.InvalidArgument),
+      )
+    })
+
+    it('requires auth', async () => {
+      // unauthed
+      const unauthedClient = createClient({
+        httpVersion: '1.1',
+        baseUrl: `http://localhost:${bsync.ctx.cfg.service.port}`,
+      })
+      const tryAddMuteOperation1 = unauthedClient.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:b',
+      })
+      await expect(tryAddMuteOperation1).rejects.toEqual(
+        new ConnectError('missing auth', Code.Unauthenticated),
+      )
+      // bad auth
+      const badauthedClient = createClient({
+        httpVersion: '1.1',
+        baseUrl: `http://localhost:${bsync.ctx.cfg.service.port}`,
+        interceptors: [authWithApiKey('key-bad')],
+      })
+      const tryAddMuteOperation2 = badauthedClient.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:b',
+      })
+      await expect(tryAddMuteOperation2).rejects.toEqual(
+        new ConnectError('invalid api key', Code.Unauthenticated),
+      )
+    })
+  })
+
+  describe('scanMuteOperations', () => {
+    it('requires auth', async () => {
+      // unauthed
+      const unauthedClient = createClient({
+        httpVersion: '1.1',
+        baseUrl: `http://localhost:${bsync.ctx.cfg.service.port}`,
+      })
+      const tryScanMuteOperations1 = unauthedClient.scanMuteOperations({})
+      await expect(tryScanMuteOperations1).rejects.toEqual(
+        new ConnectError('missing auth', Code.Unauthenticated),
+      )
+      // bad auth
+      const badauthedClient = createClient({
+        httpVersion: '1.1',
+        baseUrl: `http://localhost:${bsync.ctx.cfg.service.port}`,
+        interceptors: [authWithApiKey('key-bad')],
+      })
+      const tryScanMuteOperations2 = badauthedClient.scanMuteOperations({})
+      await expect(tryScanMuteOperations2).rejects.toEqual(
+        new ConnectError('invalid api key', Code.Unauthenticated),
+      )
+    })
+
+    it('pages over created mute ops.', async () => {
+      // add 100 mute ops
+      for (let i = 0; i < 10; ++i) {
+        for (let j = 0; j < 8; ++j) {
+          await client.addMuteOperation({
+            type: MuteOperation_Type.ADD,
+            actorDid: `did:example:${i}`,
+            subject: `did:example:${j}`,
+          })
+        }
+        for (let j = 0; j < 2; ++j) {
+          await client.addMuteOperation({
+            type: MuteOperation_Type.ADD,
+            actorDid: `did:example:${i}`,
+            subject: `at://did:example:0/app.bsky.graph.list/rkey${j}`,
+          })
+        }
+      }
+
+      let cursor: string | undefined
+      const operations: MuteOperation[] = []
+      do {
+        const res = await client.scanMuteOperations({
+          cursor,
+          limit: 30,
+        })
+        operations.push(...res.operations)
+        cursor = res.operations.length ? res.cursor : undefined
+      } while (cursor)
+
+      expect(operations.length).toEqual(100)
+      const operationIds = operations.map((op) => parseInt(op.id, 10))
+      const ascending = (a: number, b: number) => a - b
+      expect(operationIds).toEqual([...operationIds].sort(ascending))
+    })
+
+    it('supports long-poll, finding an operation.', async () => {
+      const scanPromise = client.scanMuteOperations({})
+      await wait(100) // would be complete by now if it wasn't long-polling for an item
+      const { operation } = await client.addMuteOperation({
+        type: MuteOperation_Type.ADD,
+        actorDid: 'did:example:a',
+        subject: 'did:example:b',
+      })
+      const res = await scanPromise
+      expect(res.operations.length).toEqual(1)
+      expect(res.operations[0]).toEqual(operation)
+      expect(res.cursor).toEqual(operation?.id)
+    })
+
+    it('supports long-poll, not finding an operation.', async () => {
+      const res = await client.scanMuteOperations({})
+      expect(res.cursor).toEqual('')
+      expect(res.operations).toEqual([])
+    })
+  })
+})
+
+const dumpMuteState = async (db: Database) => {
+  const items = await db.db.selectFrom('mute_item').selectAll().execute()
+  const result: Record<string, string[]> = {}
+  items.forEach((item) => {
+    result[item.actorDid] ??= []
+    result[item.actorDid].push(item.subject)
+  })
+  Object.values(result).forEach((subjects) => subjects.sort())
+  return result
+}
+
+const clearMutes = async (db: Database) => {
+  await db.db.deleteFrom('mute_item').execute()
+  await db.db.deleteFrom('mute_op').execute()
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "emitDeclarationOnly": true
+  },
+  "module": "nodenext",
+  "include": ["./src", "__tests__/**/**.ts"],
+  "references": [
+    { "path": "../common/tsconfig.build.json" },
+    { "path": "../common-web/tsconfig.build.json" }
+  ]
+}