@atproto/bsync 0.0.32 → 0.0.33

package/src/db/migrations/20240108T220751294Z-init.ts

@@ -1,26 +0,0 @@
-import { Kysely, sql } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable('mute_op')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('type', 'int2', (col) => col.notNull()) // integer enum: 0->add, 1->remove, 2->clear
-    .addColumn('actorDid', 'varchar', (col) => col.notNull())
-    .addColumn('subject', 'varchar', (col) => col.notNull())
-    .addColumn('createdAt', 'timestamptz', (col) =>
-      col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
-    )
-    .execute()
-  await db.schema
-    .createTable('mute_item')
-    .addColumn('actorDid', 'varchar', (col) => col.notNull())
-    .addColumn('subject', 'varchar', (col) => col.notNull())
-    .addColumn('fromId', 'bigint', (col) => col.notNull())
-    .addPrimaryKeyConstraint('mute_item_pkey', ['actorDid', 'subject'])
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable('mute_item').execute()
-  await db.schema.dropTable('mute_op').execute()
-}

package/src/db/migrations/20240717T224303472Z-notif-ops.ts

@@ -1,24 +0,0 @@
-import { Kysely, sql } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable('notif_op')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('actorDid', 'varchar', (col) => col.notNull())
-    .addColumn('priority', 'boolean')
-    .addColumn('createdAt', 'timestamptz', (col) =>
-      col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
-    )
-    .execute()
-  await db.schema
-    .createTable('notif_item')
-    .addColumn('actorDid', 'varchar', (col) => col.primaryKey())
-    .addColumn('priority', 'boolean', (col) => col.notNull())
-    .addColumn('fromId', 'bigint', (col) => col.notNull())
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable('notif_item').execute()
-  await db.schema.dropTable('notif_op').execute()
-}

package/src/db/migrations/20250527T022203400Z-add-operation.ts

@@ -1,20 +0,0 @@
-import { Kysely, sql } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable('operation')
-    .addColumn('id', 'bigserial', (col) => col.primaryKey())
-    .addColumn('collection', 'varchar', (col) => col.notNull())
-    .addColumn('actorDid', 'varchar', (col) => col.notNull())
-    .addColumn('rkey', 'varchar', (col) => col.notNull())
-    .addColumn('method', 'int2', (col) => col.notNull())
-    .addColumn('payload', sql`bytea`)
-    .addColumn('createdAt', 'timestamptz', (col) =>
-      col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
-    )
-    .execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable('operation').execute()
-}

package/src/db/migrations/20250603T163446567Z-alter-operation.ts

@@ -1,19 +0,0 @@
-import { Kysely } from 'kysely'
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .alterTable('operation')
-    .renameColumn('collection', 'namespace')
-    .execute()
-
-  await db.schema.alterTable('operation').renameColumn('rkey', 'key').execute()
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .alterTable('operation')
-    .renameColumn('namespace', 'collection')
-    .execute()
-
-  await db.schema.alterTable('operation').renameColumn('key', 'rkey').execute()
-}

package/src/db/migrations/index.ts

@@ -1,8 +0,0 @@
-// NOTE this file can be edited by hand, but it is also appended to by the migration:create command.
-// It's important that every migration is exported from here with the proper name. We'd simplify
-// this with kysely's FileMigrationProvider, but it doesn't play nicely with the build process.
-
-export * as _20240108T220751294Z from './20240108T220751294Z-init.js'
-export * as _20240717T224303472Z from './20240717T224303472Z-notif-ops.js'
-export * as _20250527T022203400Z from './20250527T022203400Z-add-operation.js'
-export * as _20250603T163446567Z from './20250603T163446567Z-alter-operation.js'

package/src/db/migrations/provider.ts

@@ -1,8 +0,0 @@
-import { Migration, MigrationProvider } from 'kysely/migration'
-
-export class DbMigrationProvider implements MigrationProvider {
-  constructor(private migrations: Record<string, Migration>) {}
-  async getMigrations(): Promise<Record<string, Migration>> {
-    return this.migrations
-  }
-}

package/src/db/schema/index.ts

@@ -1,16 +0,0 @@
-import { Kysely } from 'kysely'
-import * as muteItem from './mute_item.js'
-import * as muteOp from './mute_op.js'
-import * as notifItem from './notif_item.js'
-import * as notifOp from './notif_op.js'
-import * as op from './operation.js'
-
-export type DatabaseSchemaType = muteItem.PartialDB &
-  muteOp.PartialDB &
-  notifItem.PartialDB &
-  notifOp.PartialDB &
-  op.PartialDB
-
-export type DatabaseSchema = Kysely<DatabaseSchemaType>
-
-export default DatabaseSchema

package/src/db/schema/mute_item.ts

@@ -1,13 +0,0 @@
-import { Selectable } from 'kysely'
-
-export interface MuteItem {
-  actorDid: string
-  subject: string // did or aturi for list
-  fromId: number
-}
-
-export type MuteItemEntry = Selectable<MuteItem>
-
-export const tableName = 'mute_item'
-
-export type PartialDB = { [tableName]: MuteItem }

package/src/db/schema/mute_op.ts

@@ -1,18 +0,0 @@
-import { GeneratedAlways, Selectable } from 'kysely'
-import { MuteOperation_Type } from '../../proto/bsync_pb.js'
-
-export interface MuteOp {
-  id: GeneratedAlways<number>
-  type: MuteOperation_Type // integer enum: 0->add, 1->remove, 2->clear
-  actorDid: string
-  subject: string // did or aturi for list
-  createdAt: GeneratedAlways<Date>
-}
-
-export type MuteOpEntry = Selectable<MuteOp>
-
-export const tableName = 'mute_op'
-
-export type PartialDB = { [tableName]: MuteOp }
-
-export const createMuteOpChannel = 'mute_op_create' // used with listen/notify

package/src/db/schema/notif_item.ts

@@ -1,13 +0,0 @@
-import { Selectable } from 'kysely'
-
-export interface NotifItem {
-  actorDid: string
-  priority: boolean
-  fromId: number
-}
-
-export type NotifItemEntry = Selectable<NotifItem>
-
-export const tableName = 'notif_item'
-
-export type PartialDB = { [tableName]: NotifItem }

package/src/db/schema/notif_op.ts

@@ -1,16 +0,0 @@
-import { GeneratedAlways, Selectable } from 'kysely'
-
-export interface NotifOp {
-  id: GeneratedAlways<number>
-  actorDid: string
-  priority: boolean | null
-  createdAt: GeneratedAlways<Date>
-}
-
-export type NotifOpEntry = Selectable<NotifOp>
-
-export const tableName = 'notif_op'
-
-export type PartialDB = { [tableName]: NotifOp }
-
-export const createNotifOpChannel = 'notif_op_create' // used with listen/notify

package/src/db/schema/operation.ts

@@ -1,20 +0,0 @@
-import { GeneratedAlways } from 'kysely'
-import { Method } from '../../proto/bsync_pb.js'
-
-export type OperationMethod = Method.CREATE | Method.UPDATE | Method.DELETE
-
-export interface Operation {
-  id: GeneratedAlways<number>
-  actorDid: string
-  namespace: string
-  key: string
-  method: OperationMethod
-  payload: Uint8Array<ArrayBuffer>
-  createdAt: GeneratedAlways<Date>
-}
-
-export const tableName = 'operation'
-
-export type PartialDB = { [tableName]: Operation }
-
-export const createOperationChannel = 'operation_create' // used with listen/notify

package/src/db/types.ts

@@ -1,19 +0,0 @@
-import { DynamicModule, RawBuilder, SelectQueryBuilder } from 'kysely'
-// eslint-disable-next-line import/default
-import pg from 'pg'
-type PgPool = pg.Pool
-
-export type DbRef =
-  | RawBuilder<unknown>
-  | ReturnType<DynamicModule<unknown>['ref']>
-
-export type AnyQb = SelectQueryBuilder<any, any, any>
-
-export type PgOptions = {
-  url: string
-  pool?: PgPool
-  schema?: string
-  poolSize?: number
-  poolMaxUses?: number
-  poolIdleTimeoutMs?: number
-}

package/src/index.ts

@@ -1,132 +0,0 @@
-import events, { setMaxListeners } from 'node:events'
-import http from 'node:http'
-import { connectNodeAdapter } from '@connectrpc/connect-node'
-// eslint-disable-next-line import/default
-import httpTerminator from 'http-terminator'
-import { ServerConfig } from './config.js'
-import { AppContext, AppContextOptions } from './context.js'
-import { createMuteOpChannel } from './db/schema/mute_op.js'
-import { createNotifOpChannel } from './db/schema/notif_op.js'
-import { createOperationChannel } from './db/schema/operation.js'
-import { dbLogger, loggerMiddleware } from './logger.js'
-import routes from './routes/index.js'
-
-export * from './config.js'
-export * from './client.js'
-export { Database } from './db/index.js'
-export { AppContext } from './context.js'
-export { httpLogger } from './logger.js'
-
-type BsyncServiceState = 'initialized' | 'started' | 'destroyed'
-
-export class BsyncService {
-  public ctx: AppContext
-  public server: http.Server
-  private terminator: httpTerminator.HttpTerminator
-  private ac: AbortController
-  private state: BsyncServiceState = 'initialized'
-
-  constructor(opts: {
-    ctx: AppContext
-    server: http.Server
-    ac: AbortController
-  }) {
-    this.ctx = opts.ctx
-    this.server = opts.server
-    this.ac = opts.ac
-    this.terminator = httpTerminator.createHttpTerminator(opts)
-  }
-
-  static async create(
-    cfg: ServerConfig,
-    overrides?: Partial<AppContextOptions>,
-  ): Promise<BsyncService> {
-    const ac = new AbortController()
-    // Prevents unhelpful warnings.
-    setMaxListeners(100, ac.signal)
-    const ctx = await AppContext.fromConfig(cfg, ac.signal, overrides)
-    const handler = connectNodeAdapter({
-      routes: routes(ctx),
-      shutdownSignal: ac.signal,
-    })
-    const server = http.createServer((req, res) => {
-      loggerMiddleware(req, res)
-      if (isHealth(req.url)) {
-        res.statusCode = 200
-        res.setHeader('content-type', 'application/json')
-        return res.end(JSON.stringify({ version: cfg.service.version }))
-      }
-      handler(req, res)
-    })
-    return new BsyncService({ ctx, server, ac })
-  }
-
-  async start(): Promise<http.Server> {
-    if (this.state !== 'initialized') {
-      throw new Error(`${this.constructor.name} already started`)
-    }
-    this.state = 'started'
-
-    const dbStatsInterval = setInterval(() => {
-      dbLogger.info(
-        {
-          idleCount: this.ctx.db.pool.idleCount,
-          totalCount: this.ctx.db.pool.totalCount,
-          waitingCount: this.ctx.db.pool.waitingCount,
-        },
-        'db pool stats',
-      )
-    }, 10000)
-
-    this.ac.signal.addEventListener('abort', () => {
-      clearInterval(dbStatsInterval)
-    })
-
-    await this.setupAppEvents()
-    this.server.listen(this.ctx.cfg.service.port)
-    this.server.keepAliveTimeout = 90000
-    await events.once(this.server, 'listening')
-    return this.server
-  }
-
-  async destroy(): Promise<void> {
-    if (this.state === 'destroyed') return
-    this.state = 'destroyed'
-    this.ac.abort()
-    try {
-      await this.terminator.terminate()
-    } finally {
-      await this.ctx.db.close()
-    }
-  }
-
-  async setupAppEvents() {
-    const conn = await this.ctx.db.pool.connect()
-    this.ac.signal.addEventListener('abort', () => conn.release(), {
-      once: true,
-    })
-    // if these error, unhandled rejection should cause process to exit
-    conn.query(`listen ${createMuteOpChannel}`)
-    conn.query(`listen ${createNotifOpChannel}`)
-    conn.query(`listen ${createOperationChannel}`)
-    conn.on('notification', (notif) => {
-      if (notif.channel === createMuteOpChannel) {
-        this.ctx.events.emit(createMuteOpChannel)
-      }
-      if (notif.channel === createNotifOpChannel) {
-        this.ctx.events.emit(createNotifOpChannel)
-      }
-      if (notif.channel === createOperationChannel) {
-        this.ctx.events.emit(createOperationChannel)
-      }
-    })
-  }
-}
-
-export default BsyncService
-
-const isHealth = (urlStr: string | undefined) => {
-  if (!urlStr) return false
-  const url = new URL(urlStr, 'http://host')
-  return url.pathname === '/_health'
-}

package/src/logger.ts

@@ -1,26 +0,0 @@
-import { type IncomingMessage } from 'node:http'
-import { pinoHttp, stdSerializers } from 'pino-http'
-import { obfuscateHeaders, subsystemLogger } from '@atproto/common'
-
-export const dbLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsync:db')
-export const httpLogger: ReturnType<typeof subsystemLogger> =
-  subsystemLogger('bsync')
-
-export const loggerMiddleware = pinoHttp({
-  logger: httpLogger,
-  redact: {
-    paths: ['req.headers.authorization'],
-  },
-  serializers: {
-    err: (err: unknown) => ({
-      code: err?.['code'],
-      message: err?.['message'],
-    }),
-    req: (req: IncomingMessage) => {
-      const serialized = stdSerializers.req(req)
-      const headers = obfuscateHeaders(serialized.headers)
-      return { ...serialized, headers }
-    },
-  },
-})

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)
-  }
-}