@meith/db 0.16.0

package/src/two-factor-repo.ts

@@ -0,0 +1,235 @@
+import { and, count, desc, eq, isNull, lt, sql } from 'drizzle-orm'
+
+import type {
+  AuthEventKind,
+  AuthEventRecord,
+  AuthEventRepository,
+  NewAuthEvent,
+  RecoveryCodeRepository,
+  TwoFactorRecord,
+  TwoFactorRepository,
+} from '@meith/accounts'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { authEvents, recoveryCodes, userTwoFactor } from './schema'
+
+const TWO_FACTOR_COLUMNS = {
+  userId: userTwoFactor.userId,
+  sealedSecret: userTwoFactor.sealedSecret,
+  confirmedAt: userTwoFactor.confirmedAt,
+  lastStep: userTwoFactor.lastStep,
+  createdAt: userTwoFactor.createdAt,
+} as const
+
+export class PostgresTwoFactorRepository implements TwoFactorRepository {
+  constructor(private readonly db: Database) {}
+
+  async find(userId: number): Promise<TwoFactorRecord | null> {
+    const rows = await this.db
+      .select(TWO_FACTOR_COLUMNS)
+      .from(userTwoFactor)
+      .where(eq(userTwoFactor.userId, userId))
+      .limit(1)
+    return rows[0] ?? null
+  }
+
+  async startEnrolment(input: {
+    userId: number
+    sealedSecret: string
+    now: Date
+  }): Promise<TwoFactorRecord> {
+    const rows = await this.db
+      .insert(userTwoFactor)
+      .values({
+        userId: input.userId,
+        sealedSecret: input.sealedSecret,
+        confirmedAt: null,
+        lastStep: null,
+        createdAt: input.now,
+      })
+      .onConflictDoUpdate({
+        target: userTwoFactor.userId,
+        set: {
+          sealedSecret: input.sealedSecret,
+          confirmedAt: null,
+          lastStep: null,
+          createdAt: input.now,
+        },
+        setWhere: isNull(userTwoFactor.confirmedAt),
+      })
+      .returning(TWO_FACTOR_COLUMNS)
+
+    const record = rows[0] ?? (await this.find(input.userId))
+    if (record === null || record === undefined) {
+      throw new Error('the two-factor enrolment vanished between insert and read')
+    }
+    return record
+  }
+
+  async confirm(userId: number, step: number, now: Date): Promise<boolean> {
+    const rows = await this.db
+      .update(userTwoFactor)
+      .set({ confirmedAt: now, lastStep: step })
+      .where(and(eq(userTwoFactor.userId, userId), isNull(userTwoFactor.confirmedAt)))
+      .returning({ userId: userTwoFactor.userId })
+    return rows.length > 0
+  }
+
+  async spendStep(userId: number, step: number): Promise<boolean> {
+    const rows = await this.db
+      .update(userTwoFactor)
+      .set({ lastStep: step })
+      .where(
+        and(
+          eq(userTwoFactor.userId, userId),
+          sql`(${userTwoFactor.lastStep} is null or ${userTwoFactor.lastStep} < ${step})`,
+        ),
+      )
+      .returning({ userId: userTwoFactor.userId })
+    return rows.length > 0
+  }
+
+  async remove(userId: number): Promise<boolean> {
+    const rows = await this.db
+      .delete(userTwoFactor)
+      .where(eq(userTwoFactor.userId, userId))
+      .returning({ userId: userTwoFactor.userId })
+    return rows.length > 0
+  }
+}
+
+export class PostgresRecoveryCodeRepository implements RecoveryCodeRepository {
+  constructor(private readonly db: Database) {}
+
+  async replaceAll(userId: number, hashes: readonly string[], now: Date): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      await tx.delete(recoveryCodes).where(eq(recoveryCodes.userId, userId))
+
+      if (hashes.length === 0) return
+
+      await tx
+        .insert(recoveryCodes)
+        .values(hashes.map((codeHash) => ({ userId, codeHash, createdAt: now })))
+    })
+  }
+
+  async spend(userId: number, hash: string, now: Date): Promise<boolean> {
+    const rows = await this.db
+      .update(recoveryCodes)
+      .set({ usedAt: now })
+      .where(
+        and(
+          eq(recoveryCodes.userId, userId),
+          eq(recoveryCodes.codeHash, hash),
+          isNull(recoveryCodes.usedAt),
+        ),
+      )
+      .returning({ id: recoveryCodes.id })
+    return rows.length > 0
+  }
+
+  async countUnused(userId: number): Promise<number> {
+    const rows = await this.db
+      .select({ total: count() })
+      .from(recoveryCodes)
+      .where(and(eq(recoveryCodes.userId, userId), isNull(recoveryCodes.usedAt)))
+    return Number(rows[0]?.total ?? 0)
+  }
+
+  async removeAll(userId: number): Promise<void> {
+    await this.db.delete(recoveryCodes).where(eq(recoveryCodes.userId, userId))
+  }
+}
+
+const EVENT_COLUMNS = {
+  id: authEvents.id,
+  userId: authEvents.userId,
+  kind: authEvents.kind,
+  ipPrefix: authEvents.ipPrefix,
+  userAgent: authEvents.userAgent,
+  detail: authEvents.detail,
+  at: authEvents.at,
+} as const
+
+function toEvent(row: {
+  id: number
+  userId: number | null
+  kind: string
+  ipPrefix: string | null
+  userAgent: string | null
+  detail: unknown
+  at: Date
+}): AuthEventRecord {
+  return {
+    id: row.id,
+    userId: row.userId,
+    kind: row.kind as AuthEventKind,
+    ipPrefix: row.ipPrefix,
+    userAgent: row.userAgent,
+    detail:
+      typeof row.detail === 'object' && row.detail !== null
+        ? (row.detail as Record<string, unknown>)
+        : {},
+    at: row.at,
+  }
+}
+
+export class PostgresAuthEventRepository implements AuthEventRepository {
+  constructor(private readonly db: Database) {}
+
+  async record(event: NewAuthEvent): Promise<void> {
+    await this.db.insert(authEvents).values({
+      userId: event.userId,
+      kind: event.kind,
+      ipPrefix: event.ipPrefix ?? null,
+      userAgent: event.userAgent ?? null,
+      detail: event.detail ?? {},
+      at: event.at,
+    })
+  }
+
+  async listForUser(userId: number, limit: number): Promise<readonly AuthEventRecord[]> {
+    const rows = await this.db
+      .select(EVENT_COLUMNS)
+      .from(authEvents)
+      .where(eq(authEvents.userId, userId))
+      .orderBy(desc(authEvents.id))
+      .limit(limit)
+    return rows.map(toEvent)
+  }
+
+  async listRecent(input: {
+    limit: number
+    before?: number | undefined
+    kind?: AuthEventKind | undefined
+  }): Promise<readonly AuthEventRecord[]> {
+    const filters = [
+      input.before === undefined ? undefined : lt(authEvents.id, input.before),
+      input.kind === undefined ? undefined : eq(authEvents.kind, input.kind),
+    ].filter((filter) => filter !== undefined)
+
+    const rows = await this.db
+      .select(EVENT_COLUMNS)
+      .from(authEvents)
+      .where(filters.length === 0 ? undefined : and(...filters))
+      .orderBy(desc(authEvents.id))
+      .limit(input.limit)
+    return rows.map(toEvent)
+  }
+
+  async pruneBefore(cutoff: Date, limit = 5000): Promise<number> {
+    const result = await this.db.execute(sql`
+      delete from ${authEvents}
+       where id in (
+         select id from ${authEvents}
+          where at < ${cutoff}
+          order by id
+          limit ${limit}
+       )
+      returning id
+    `)
+
+    return resultRows(result).length
+  }
+}

package/src/upgrade-repo.ts

@@ -0,0 +1,66 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+
+export async function readVersion(db: Database, component: string): Promise<string | null> {
+  const rows = (await db.execute(sql`
+    select version from component_versions where component = ${component}
+  `)) as unknown as { version: string }[]
+  return rows[0]?.version ?? null
+}
+
+export async function readVersions(db: Database): Promise<Readonly<Record<string, string>>> {
+  const rows = (await db.execute(sql`
+    select component, version from component_versions order by component
+  `)) as unknown as { component: string; version: string }[]
+
+  return Object.fromEntries(rows.map((row) => [row.component, row.version]))
+}
+
+export async function recordVersion(
+  db: Database,
+  component: string,
+  version: string,
+): Promise<void> {
+  await db.execute(sql`
+    insert into component_versions (component, version, updated_at)
+    values (${component}, ${version}, now())
+    on conflict (component) do update set version = excluded.version, updated_at = now()
+  `)
+}
+
+export async function appliedPluginMigrations(
+  db: Database,
+  pluginKey: string,
+): Promise<readonly string[]> {
+  const rows = (await db.execute(sql`
+    select migration_id from plugin_migrations
+    where plugin_key = ${pluginKey}
+    order by migration_id
+  `)) as unknown as { migration_id: string }[]
+
+  return rows.map((row) => row.migration_id)
+}
+
+export async function applyPluginMigration(
+  db: Database,
+  pluginKey: string,
+  migrationId: string,
+  statements: readonly string[],
+): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const claimed = (await tx.execute(sql`
+      insert into plugin_migrations (plugin_key, migration_id)
+      values (${pluginKey}, ${migrationId})
+      on conflict (plugin_key, migration_id) do nothing
+      returning migration_id
+    `)) as unknown as unknown[]
+
+    if (claimed.length === 0) return false
+
+    for (const statement of statements) {
+      await tx.execute(sql.raw(statement))
+    }
+    return true
+  })
+}

package/src/user-admin-repo.ts

@@ -0,0 +1,367 @@
+import { type SQL, sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { Database } from './client'
+import { rewriteDenormalisedUsernames } from './denormalised-username'
+import { withPermissionVersionBump } from './permission-version'
+import { resultRows } from './result-rows'
+import { toDate, toNullableDate } from './row-values'
+
+export type AccountState = 'active' | 'awaiting_activation' | 'banned'
+
+const STATES: readonly AccountState[] = ['active', 'awaiting_activation', 'banned']
+
+export const BANNED_PREDICATE: SQL = sql`(u.state = 'banned' or exists (
+  select 1 from bans b where b.user_id = u.id and b.lifted_at is null
+))`
+
+export interface UserSearchFilter {
+  readonly username?: string | undefined
+  readonly email?: string | undefined
+  readonly ipPrefix?: string | undefined
+  readonly primaryGroupId?: number | undefined
+  readonly state?: AccountState | undefined
+  readonly registeredBefore?: Date | undefined
+  readonly registeredAfter?: Date | undefined
+  readonly minPostCount?: number | undefined
+  readonly maxPostCount?: number | undefined
+  readonly includeDeleted?: boolean | undefined
+  readonly afterUserId?: number | undefined
+  readonly offset?: number | undefined
+  readonly limit: number
+}
+
+export interface UserSearchRow {
+  readonly id: number
+  readonly username: string
+  readonly email: string
+  readonly state: AccountState
+  readonly isBanned: boolean
+  readonly primaryGroupId: number
+  readonly primaryGroupTitle: string
+  readonly postCount: number
+  readonly reputation: number
+  readonly warningPoints: number
+  readonly registrationIpPrefix: string | null
+  readonly lastIpPrefix: string | null
+  readonly lastActiveAt: Date | null
+  readonly createdAt: Date
+  readonly deletedAt: Date | null
+}
+
+export interface UserSearchPage {
+  readonly rows: readonly UserSearchRow[]
+  readonly nextCursor: number | null
+  /** How many accounts the filter matches, whichever page was asked for. */
+  readonly total: number
+}
+
+export interface UserDetail extends UserSearchRow {
+  readonly displayGroupId: number | null
+  readonly emailVerifiedAt: Date | null
+  readonly passwordChangedAt: Date | null
+  readonly threadCount: number
+  readonly legacyId: number | null
+}
+
+export interface UserAccountInput {
+  readonly username: string
+  readonly email: string
+  readonly primaryGroupId: number
+  readonly displayGroupId: number | null
+}
+
+export function likeFragment(value: string): string {
+  return value.replace(/[\\%_]/g, (character) => `\\${character}`)
+}
+
+function fold(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+function assertState(state: string): AccountState {
+  if (!STATES.includes(state as AccountState)) {
+    throw new ValidationError(msg('error.db.such-account-state'))
+  }
+  return state as AccountState
+}
+
+function toSearchRow(row: Record<string, unknown>): UserSearchRow {
+  return {
+    id: Number(row.id),
+    username: String(row.username),
+    email: String(row.email),
+    state: assertState(String(row.state)),
+    isBanned: row.is_banned === true || row.is_banned === 't',
+    primaryGroupId: Number(row.primary_group_id),
+    primaryGroupTitle: String(row.primary_group_title ?? ''),
+    postCount: Number(row.post_count),
+    reputation: Number(row.reputation),
+    warningPoints: Number(row.warning_points),
+    registrationIpPrefix:
+      row.registration_ip_prefix === null ? null : String(row.registration_ip_prefix),
+    lastIpPrefix: row.last_ip_prefix === null ? null : String(row.last_ip_prefix),
+    lastActiveAt: toNullableDate(row.last_active_at),
+    createdAt: toDate(row.created_at),
+    deletedAt: toNullableDate(row.deleted_at),
+  }
+}
+
+export class PostgresUserAdminRepository {
+  constructor(private readonly db: Database) {}
+
+  async search(filter: UserSearchFilter): Promise<UserSearchPage> {
+    const conditions: SQL[] = []
+
+    if (filter.afterUserId !== undefined && filter.afterUserId > 0) {
+      conditions.push(sql`u.id > ${filter.afterUserId}`)
+    }
+
+    if (filter.username !== undefined && filter.username.trim() !== '') {
+      conditions.push(
+        sql`u.username_lower like ${`%${likeFragment(fold(filter.username))}%`} escape '\\'`,
+      )
+    }
+    if (filter.email !== undefined && filter.email.trim() !== '') {
+      conditions.push(
+        sql`u.email_lower like ${`%${likeFragment(fold(filter.email))}%`} escape '\\'`,
+      )
+    }
+    if (filter.ipPrefix !== undefined && filter.ipPrefix.trim() !== '') {
+      const pattern = `${likeFragment(filter.ipPrefix.trim())}%`
+      conditions.push(
+        sql`(u.registration_ip_prefix like ${pattern} escape '\\'
+             or u.last_ip_prefix like ${pattern} escape '\\')`,
+      )
+    }
+    if (filter.primaryGroupId !== undefined) {
+      conditions.push(sql`u.primary_group_id = ${filter.primaryGroupId}`)
+    }
+    if (filter.state !== undefined) {
+      const state = assertState(filter.state)
+      conditions.push(
+        state === 'banned' ? BANNED_PREDICATE : sql`u.state = ${state} and not ${BANNED_PREDICATE}`,
+      )
+    }
+    if (filter.registeredAfter !== undefined) {
+      conditions.push(sql`u.created_at >= ${filter.registeredAfter}`)
+    }
+    if (filter.registeredBefore !== undefined) {
+      conditions.push(sql`u.created_at < ${filter.registeredBefore}`)
+    }
+    if (filter.minPostCount !== undefined) {
+      conditions.push(sql`u.post_count >= ${filter.minPostCount}`)
+    }
+    if (filter.maxPostCount !== undefined) {
+      conditions.push(sql`u.post_count <= ${filter.maxPostCount}`)
+    }
+    if (filter.includeDeleted !== true) {
+      conditions.push(sql`u.deleted_at is null`)
+    }
+
+    const where = conditions.length === 0 ? sql`true` : sql.join(conditions, sql` and `)
+    const offset = filter.offset ?? 0
+
+    const [listed, counted] = await Promise.all([
+      this.db.execute(sql`
+        select u.id, u.username, u.email, u.state, u.primary_group_id,
+               g.title as primary_group_title,
+               u.post_count, u.reputation, u.warning_points,
+               u.registration_ip_prefix, u.last_ip_prefix,
+               u.last_active_at, u.created_at, u.deleted_at,
+               ${BANNED_PREDICATE} as is_banned
+          from users u
+          join usergroups g on g.id = u.primary_group_id
+         where ${where}
+         order by u.id
+         limit ${filter.limit} offset ${offset}
+      `),
+      this.db.execute(sql`
+        select count(*)::int as total
+          from users u
+         where ${where}
+      `),
+    ])
+
+    const mapped = (resultRows(listed) as Array<Record<string, unknown>>).map(toSearchRow)
+    const total = Number((resultRows(counted) as Array<Record<string, unknown>>)[0]?.total ?? 0)
+
+    return {
+      rows: mapped,
+      nextCursor: mapped.length < filter.limit ? null : (mapped[mapped.length - 1]?.id ?? null),
+      total,
+    }
+  }
+
+  async readDetail(userId: number): Promise<UserDetail | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select u.*, g.title as primary_group_title,
+               ${BANNED_PREDICATE} as is_banned
+          from users u
+          join usergroups g on g.id = u.primary_group_id
+         where u.id = ${userId}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    if (row === undefined) return null
+
+    return {
+      ...toSearchRow(row),
+      displayGroupId: row.display_group_id === null ? null : Number(row.display_group_id),
+      emailVerifiedAt: toNullableDate(row.email_verified_at),
+      passwordChangedAt: toNullableDate(row.password_changed_at),
+      threadCount: Number(row.thread_count),
+      legacyId: row.legacy_id === null ? null : Number(row.legacy_id),
+    }
+  }
+
+  async updateAccount(userId: number, input: UserAccountInput): Promise<void> {
+    const username = input.username.trim()
+    const email = input.email.trim()
+    if (username === '') throw new ValidationError(msg('error.db.member-needs-username'))
+    if (email === '') throw new ValidationError(msg('error.db.member-needs-email-address'))
+
+    const primaryGroupId = input.primaryGroupId
+
+    await withPermissionVersionBump(this.db, async (tx) => {
+      const named = resultRows(
+        await tx.execute(sql`select username from users where id = ${userId}`),
+      ) as Array<{ username: string }>
+
+      const previous = named[0]?.username
+
+      const rows = resultRows(
+        await tx.execute(sql`
+          update users
+             set username = ${username},
+                 username_lower = ${fold(username)},
+                 email = ${email},
+                 email_lower = ${fold(email)},
+                 primary_group_id = ${primaryGroupId},
+                 display_group_id = ${input.displayGroupId},
+                 updated_at = now()
+           where id = ${userId}
+          returning id
+        `),
+      ) as Array<{ id: number }>
+
+      if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-member'))
+
+      if (previous !== username) {
+        await rewriteDenormalisedUsernames(tx, userId, username)
+      }
+    })
+  }
+
+  async setState(userId: number, state: AccountState): Promise<void> {
+    if (state === 'banned') {
+      throw new ValidationError(msg('error.db.bans-issued-through-ban-screen'))
+    }
+
+    await withPermissionVersionBump(this.db, async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`
+          update users u set state = ${assertState(state)}, updated_at = now()
+           where u.id = ${userId} and not ${BANNED_PREDICATE}
+          returning u.id
+        `),
+      ) as Array<{ id: number }>
+
+      if (rows[0] === undefined) {
+        throw new ValidationError(msg('error.db.such-member-member-under-ban'))
+      }
+    })
+  }
+
+  async sharingIpPrefix(
+    prefix: string,
+    excludeUserId: number,
+    limit = 50,
+  ): Promise<readonly UserSearchRow[]> {
+    if (prefix.trim() === '') return []
+
+    const pattern = `${likeFragment(prefix.trim())}%`
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select u.id, u.username, u.email, u.state, u.primary_group_id,
+               g.title as primary_group_title,
+               u.post_count, u.reputation, u.warning_points,
+               u.registration_ip_prefix, u.last_ip_prefix,
+               u.last_active_at, u.created_at, u.deleted_at
+          from users u
+          join usergroups g on g.id = u.primary_group_id
+         where u.id <> ${excludeUserId}
+           and (u.registration_ip_prefix like ${pattern} escape '\\'
+                or u.last_ip_prefix like ${pattern} escape '\\')
+         order by u.id
+         limit ${limit}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map(toSearchRow)
+  }
+
+  async readSecondaryGroups(userId: number): Promise<readonly number[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select group_id from user_group_memberships
+         where user_id = ${userId}
+         order by group_id
+      `),
+    ) as Array<{ group_id: number }>
+
+    return rows.map((row) => Number(row.group_id))
+  }
+
+  async setSecondaryGroups(
+    userId: number,
+    groupIds: readonly number[],
+    grantedByUserId: number | null,
+  ): Promise<void> {
+    await withPermissionVersionBump(this.db, async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`select primary_group_id from users where id = ${userId}`),
+      ) as Array<Record<string, unknown>>
+
+      if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-member'))
+      const primary = Number(rows[0].primary_group_id)
+
+      const wanted = new Set([...groupIds].filter((id) => id !== primary))
+
+      const held = resultRows(
+        await tx.execute(sql`
+          select group_id from user_group_memberships where user_id = ${userId}
+        `),
+      ) as Array<{ group_id: number }>
+      const existing = new Set(held.map((row) => Number(row.group_id)))
+
+      for (const groupId of existing) {
+        if (wanted.has(groupId) || groupId === primary) continue
+        await tx.execute(sql`
+          delete from user_group_memberships
+           where user_id = ${userId} and group_id = ${groupId}
+        `)
+      }
+
+      for (const groupId of wanted) {
+        if (existing.has(groupId)) continue
+        await tx.execute(sql`
+          insert into user_group_memberships (user_id, group_id, granted_by_user_id)
+          values (${userId}, ${groupId}, ${grantedByUserId})
+        `)
+      }
+    })
+  }
+
+  async listGroups(): Promise<readonly { readonly id: number; readonly title: string }[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`select id, title from usergroups order by display_order, id`),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({ id: Number(row.id), title: String(row.title) }))
+  }
+}