@atproto/bsync 0.0.31 → 0.0.33

package/src/db/index.ts

@@ -1,200 +0,0 @@
-import assert from 'node:assert'
-import { EventEmitter } from 'node:events'
-import {
-  Kysely,
-  KyselyPlugin,
-  PluginTransformQueryArgs,
-  PluginTransformResultArgs,
-  PostgresDialect,
-  QueryResult,
-  RootOperationNode,
-  UnknownRow,
-} from 'kysely'
-import { Migrator } from 'kysely/migration'
-// eslint-disable-next-line import/default
-import pg from 'pg'
-// eslint-disable-next-line import/no-named-as-default-member
-const { Pool: PgPool, types: pgTypes } = pg
-type PgPool = InstanceType<typeof PgPool>
-import type TypedEmitter from 'typed-emitter'
-import { dbLogger } from '../logger.js'
-import * as migrations from './migrations/index.js'
-import { DbMigrationProvider } from './migrations/provider.js'
-import { DatabaseSchema, DatabaseSchemaType } from './schema/index.js'
-import { PgOptions } from './types.js'
-
-export class Database {
-  pool: PgPool
-  db: DatabaseSchema
-  migrator: Migrator
-  txEvt = new EventEmitter() as TxnEmitter
-  destroyed = false
-
-  constructor(
-    public opts: PgOptions,
-    instances?: { db: DatabaseSchema; pool: PgPool },
-  ) {
-    // if instances are provided, use those
-    if (instances) {
-      this.db = instances.db
-      this.pool = instances.pool
-    } else {
-      // else create a pool & connect
-      const { schema, url } = opts
-      const pool =
-        opts.pool ??
-        new PgPool({
-          connectionString: url,
-          max: opts.poolSize,
-          maxUses: opts.poolMaxUses,
-          idleTimeoutMillis: opts.poolIdleTimeoutMs,
-        })
-
-      // Select count(*) and other pg bigints as js integer
-      pgTypes.setTypeParser(pgTypes.builtins.INT8, (n) => parseInt(n, 10))
-
-      // Setup schema usage, primarily for test parallelism (each test suite runs in its own pg schema)
-      if (schema && !/^[a-z_]+$/i.test(schema)) {
-        throw new Error(
-          `Postgres schema must only contain [A-Za-z_]: ${schema}`,
-        )
-      }
-
-      pool.on('error', onPoolError)
-      pool.on('connect', (client) => {
-        client.on('error', onClientError)
-        if (schema) {
-          // Shared objects such as extensions will go in the public schema
-          client.query(`SET search_path TO "${schema}",public;`)
-        }
-      })
-
-      this.pool = pool
-      this.db = new Kysely<DatabaseSchemaType>({
-        dialect: new PostgresDialect({ pool }),
-      })
-    }
-
-    this.migrator = new Migrator({
-      db: this.db,
-      migrationTableSchema: opts.schema,
-      provider: new DbMigrationProvider(migrations),
-    })
-  }
-
-  get schema(): string | undefined {
-    return this.opts.schema
-  }
-
-  get isTransaction() {
-    return this.db.isTransaction
-  }
-
-  assertTransaction() {
-    assert(this.isTransaction, 'Transaction required')
-  }
-
-  assertNotTransaction() {
-    assert(!this.isTransaction, 'Cannot be in a transaction')
-  }
-
-  async transaction<T>(fn: (db: Database) => Promise<T>): Promise<T> {
-    const leakyTxPlugin = new LeakyTxPlugin()
-    const { dbTxn, txRes } = await this.db
-      .withPlugin(leakyTxPlugin)
-      .transaction()
-      .execute(async (txn) => {
-        const dbTxn = new Database(this.opts, {
-          db: txn,
-          pool: this.pool,
-        })
-        const txRes = await fn(dbTxn)
-          .catch(async (err) => {
-            leakyTxPlugin.endTx()
-            // ensure that all in-flight queries are flushed & the connection is open
-            await dbTxn.db.getExecutor().provideConnection(noopAsync)
-            throw err
-          })
-          .finally(() => leakyTxPlugin.endTx())
-        return { dbTxn, txRes }
-      })
-    dbTxn?.txEvt.emit('commit')
-    return txRes
-  }
-
-  onCommit(fn: () => void) {
-    this.assertTransaction()
-    this.txEvt.once('commit', fn)
-  }
-
-  async close(): Promise<void> {
-    if (this.destroyed) return
-    await this.db.destroy()
-    this.destroyed = true
-  }
-
-  async migrateToOrThrow(migration: string) {
-    if (this.schema) {
-      await this.db.schema.createSchema(this.schema).ifNotExists().execute()
-    }
-    const { error, results } = await this.migrator.migrateTo(migration)
-    if (error) {
-      throw error
-    }
-    if (!results) {
-      throw new Error('An unknown failure occurred while migrating')
-    }
-    return results
-  }
-
-  async migrateToLatestOrThrow() {
-    if (this.schema) {
-      await this.db.schema.createSchema(this.schema).ifNotExists().execute()
-    }
-    const { error, results } = await this.migrator.migrateToLatest()
-    if (error) {
-      throw error
-    }
-    if (!results) {
-      throw new Error('An unknown failure occurred while migrating')
-    }
-    return results
-  }
-}
-
-export default Database
-
-const onPoolError = (err: Error) => dbLogger.error({ err }, 'db pool error')
-const onClientError = (err: Error) => dbLogger.error({ err }, 'db client error')
-
-// utils
-// -------
-
-class LeakyTxPlugin implements KyselyPlugin {
-  private txOver = false
-
-  endTx() {
-    this.txOver = true
-  }
-
-  transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
-    if (this.txOver) {
-      throw new Error('tx already failed')
-    }
-    return args.node
-  }
-
-  async transformResult(
-    args: PluginTransformResultArgs,
-  ): Promise<QueryResult<UnknownRow>> {
-    return args.result
-  }
-}
-
-type TxnEmitter = TypedEmitter.default<TxnEvents>
-
-type TxnEvents = {
-  commit: () => void
-}
-
-const noopAsync = async () => {}

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,130 +0,0 @@
-import events 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()
-    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 }
-    },
-  },
-})