@atproto/bsync 0.0.31 → 0.0.33

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

@@ -1,154 +0,0 @@
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { AtUri } from '@atproto/syntax'
-import { AppContext } from '../context.js'
-import { Database } from '../db/index.js'
-import { createMuteOpChannel } from '../db/schema/mute_op.js'
-import { Service } from '../proto/bsync_connect.js'
-import {
-  AddMuteOperationResponse,
-  MuteOperation_Type,
-} from '../proto/bsync_pb.js'
-import { authWithApiKey } from './auth.js'
-import { isValidAtUri, isValidDid } from './util.js'
-
-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' &&
-        uri.collection !== 'app.bsky.feed.post'
-      ) {
-        throw new ConnectError(
-          'subject aturis must reference a list or post 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
-}
-
-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/add-notif-operation.ts

@@ -1,80 +0,0 @@
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { AppContext } from '../context.js'
-import { Database } from '../db/index.js'
-import { createNotifOpChannel } from '../db/schema/notif_op.js'
-import { Service } from '../proto/bsync_connect.js'
-import { AddNotifOperationResponse } from '../proto/bsync_pb.js'
-import { authWithApiKey } from './auth.js'
-import { isValidDid } from './util.js'
-
-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/auth.ts

@@ -1,15 +0,0 @@
-import { Code, ConnectError, HandlerContext } from '@connectrpc/connect'
-import { AppContext } from '../context.js'
-
-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/delete-operations.ts

@@ -1,45 +0,0 @@
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
-import { AppContext } from '../context.js'
-import { Service } from '../proto/bsync_connect.js'
-import { DeleteOperationsByActorAndNamespaceResponse } from '../proto/bsync_pb.js'
-import { authWithApiKey } from './auth.js'
-import { isValidDid, validateNamespace } from './util.js'
-
-export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
-  /**
-   * This method is responsible for deleting log rows from the bsync db, it has
-   * no other downstream effects. This method is called from the dataplane in
-   * response to a data deletion request initiated by a moderator in Ozone.
-   * It's the final step of the deletion process, basically cleaning up the
-   * breadcrumbs that resulted in the state we store in the dataplane.
-   */
-  async deleteOperationsByActorAndNamespace(req, handlerCtx) {
-    authWithApiKey(ctx, handlerCtx)
-    const { db } = ctx
-
-    try {
-      validateNamespace(req.namespace)
-    } catch (error) {
-      throw new ConnectError(
-        'requested namespace for deletion is invalid NSID',
-        Code.InvalidArgument,
-      )
-    }
-    if (!isValidDid(req.actorDid)) {
-      throw new ConnectError(
-        'requested actor_did for deletion is invalid DID',
-        Code.InvalidArgument,
-      )
-    }
-
-    const deletedRows = await db.db
-      .deleteFrom('operation')
-      .where('actorDid', '=', req.actorDid)
-      .where('namespace', '=', req.namespace)
-      .returning('id')
-      .execute()
-    return new DeleteOperationsByActorAndNamespaceResponse({
-      deletedCount: deletedRows.length,
-    })
-  },
-})

package/src/routes/index.ts

@@ -1,28 +0,0 @@
-import { ConnectRouter } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { AppContext } from '../context.js'
-import { Service } from '../proto/bsync_connect.js'
-import addMuteOperation from './add-mute-operation.js'
-import addNotifOperation from './add-notif-operation.js'
-import deleteOperations from './delete-operations.js'
-import putOperation from './put-operation.js'
-import scanMuteOperations from './scan-mute-operations.js'
-import scanNotifOperations from './scan-notif-operations.js'
-import scanOperations from './scan-operations.js'
-
-export default (ctx: AppContext) => (router: ConnectRouter) => {
-  return router.service(Service, {
-    ...addMuteOperation(ctx),
-    ...scanMuteOperations(ctx),
-    ...addNotifOperation(ctx),
-    ...scanNotifOperations(ctx),
-    ...putOperation(ctx),
-    ...scanOperations(ctx),
-    ...deleteOperations(ctx),
-    async ping() {
-      const { db } = ctx
-      await sql`select 1`.execute(db.db)
-      return {}
-    },
-  })
-}

package/src/routes/put-operation.ts

@@ -1,115 +0,0 @@
-import { Code, ConnectError, ServiceImpl } from '@connectrpc/connect'
-import { sql } from 'kysely'
-import { ensureValidRecordKey } from '@atproto/syntax'
-import { AppContext } from '../context.js'
-import { Database } from '../db/index.js'
-import {
-  OperationMethod,
-  createOperationChannel,
-} from '../db/schema/operation.js'
-import { Service } from '../proto/bsync_connect.js'
-import {
-  Method,
-  PutOperationRequest,
-  PutOperationResponse,
-} from '../proto/bsync_pb.js'
-import { authWithApiKey } from './auth.js'
-import { isValidDid, validateNamespace } from './util.js'
-
-export default (ctx: AppContext): Partial<ServiceImpl<typeof Service>> => ({
-  async putOperation(req, handlerCtx) {
-    authWithApiKey(ctx, handlerCtx)
-    const { db } = ctx
-    const op = validateOp(req)
-    const id = await db.transaction(async (txn) => {
-      return putOp(txn, op)
-    })
-    return new PutOperationResponse({
-      operation: {
-        id: String(id),
-        actorDid: op.actorDid,
-        namespace: op.namespace,
-        key: op.key,
-        method: op.method,
-        payload: op.payload,
-      },
-    })
-  },
-})
-
-const putOp = async (db: Database, op: Operation) => {
-  const { ref } = db.db.dynamic
-  const { id } = await db.db
-    .insertInto('operation')
-    .values({
-      actorDid: op.actorDid,
-      namespace: op.namespace,
-      key: op.key,
-      method: op.method,
-      payload: op.payload,
-    })
-    .returning('id')
-    .executeTakeFirstOrThrow()
-  await sql`notify ${ref(createOperationChannel)}`.execute(db.db) // emitted transactionally
-  return id
-}
-
-const validateOp = (req: PutOperationRequest): Operation => {
-  try {
-    validateNamespace(req.namespace)
-  } catch (error) {
-    throw new ConnectError(
-      'operation namespace is invalid NSID',
-      Code.InvalidArgument,
-    )
-  }
-
-  if (!isValidDid(req.actorDid)) {
-    throw new ConnectError(
-      'operation actor_did is invalid DID',
-      Code.InvalidArgument,
-    )
-  }
-
-  try {
-    ensureValidRecordKey(req.key)
-  } catch (error) {
-    throw new ConnectError('operation key is required', Code.InvalidArgument)
-  }
-
-  if (
-    req.method !== Method.CREATE &&
-    req.method !== Method.UPDATE &&
-    req.method !== Method.DELETE
-  ) {
-    throw new ConnectError('operation method is invalid', Code.InvalidArgument)
-  }
-
-  if (req.method === Method.CREATE || req.method === Method.UPDATE) {
-    try {
-      JSON.parse(new TextDecoder().decode(req.payload))
-    } catch (error) {
-      throw new ConnectError(
-        'payload must be a valid JSON when method is CREATE or UPDATE',
-        Code.InvalidArgument,
-      )
-    }
-  }
-
-  if (req.method === Method.DELETE && req.payload.length > 0) {
-    throw new ConnectError(
-      'cannot specify a payload when method is DELETE',
-      Code.InvalidArgument,
-    )
-  }
-
-  return req as Operation
-}
-
-type Operation = {
-  actorDid: string
-  namespace: string
-  key: string
-  payload: Uint8Array<ArrayBuffer>
-  method: OperationMethod
-}

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

@@ -1,65 +0,0 @@
-import { once } from 'node:events'
-import { ServiceImpl } from '@connectrpc/connect'
-import { AppContext } from '../context.js'
-import { createMuteOpChannel } from '../db/schema/mute_op.js'
-import { Service } from '../proto/bsync_connect.js'
-import { ScanMuteOperationsResponse } from '../proto/bsync_pb.js'
-import { authWithApiKey } from './auth.js'
-import { combineSignals, validCursor } from './util.js'
-
-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: combineSignals(
-        ctx.shutdown,
-        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) {
-        ctx.shutdown.throwIfAborted()
-        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(),
-    })
-  },
-})

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

@@ -1,64 +0,0 @@
-import { once } from 'node:events'
-import { ServiceImpl } from '@connectrpc/connect'
-import { AppContext } from '../context.js'
-import { createNotifOpChannel } from '../db/schema/notif_op.js'
-import { Service } from '../proto/bsync_connect.js'
-import { ScanNotifOperationsResponse } from '../proto/bsync_pb.js'
-import { authWithApiKey } from './auth.js'
-import { combineSignals, validCursor } from './util.js'
-
-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/scan-operations.ts

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