@meith/db 0.16.0

package/src/admin-repo.ts

@@ -0,0 +1,85 @@
+import { eq, or, sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { cacheVersions, usergroups, users } from './schema'
+
+export interface UserSummary {
+  readonly id: number
+  readonly username: string
+  readonly primaryGroupId: number | null
+}
+
+export interface GroupSummary {
+  readonly id: number
+  readonly key: string
+  readonly title: string
+}
+
+function numericOr(reference: string): number | null {
+  const value = Number(reference)
+  return Number.isInteger(value) && reference.trim() !== '' ? value : null
+}
+
+export class PostgresAdminRepository {
+  constructor(private readonly db: Database) {}
+
+  async findUser(reference: string, usernameLower: string): Promise<UserSummary | null> {
+    const id = numericOr(reference)
+    const rows = await this.db
+      .select({
+        id: users.id,
+        username: users.username,
+        primaryGroupId: users.primaryGroupId,
+      })
+      .from(users)
+      .where(
+        id === null
+          ? eq(users.usernameLower, usernameLower)
+          : or(eq(users.id, id), eq(users.usernameLower, usernameLower)),
+      )
+      .limit(1)
+
+    return rows[0] ?? null
+  }
+
+  async findGroup(reference: string): Promise<GroupSummary | null> {
+    const id = numericOr(reference)
+    const rows = await this.db
+      .select({ id: usergroups.id, key: usergroups.key, title: usergroups.title })
+      .from(usergroups)
+      .where(
+        id === null
+          ? eq(usergroups.key, reference)
+          : or(eq(usergroups.id, id), eq(usergroups.key, reference)),
+      )
+      .limit(1)
+
+    return rows[0] ?? null
+  }
+
+  async listGroupKeys(): Promise<string[]> {
+    const rows = await this.db.select({ key: usergroups.key }).from(usergroups)
+    return rows.map((r) => r.key)
+  }
+
+  async setPrimaryGroup(userId: number, groupId: number): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      await tx
+        .update(users)
+        .set({ primaryGroupId: groupId, displayGroupId: groupId })
+        .where(eq(users.id, userId))
+
+      await tx
+        .insert(cacheVersions)
+        .values({ key: 'permissions', version: 1 })
+        .onConflictDoUpdate({
+          target: cacheVersions.key,
+          set: { version: sql`${cacheVersions.version} + 1`, bumpedAt: new Date() },
+        })
+    })
+  }
+
+  async registeredGroupId(): Promise<number | null> {
+    return (await this.findGroup('registered'))?.id ?? null
+  }
+}

package/src/admin-session-repo.ts

@@ -0,0 +1,205 @@
+import { sql } from 'drizzle-orm'
+
+import type {
+  AdminLogRepository,
+  AdminLogRow,
+  AdminSessionRecord,
+  AdminSessionRepository,
+} from '@meith/admin'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate, toNullableDate } from './row-values'
+
+interface RawSession {
+  id: number
+  user_id: number
+  ip_prefix: string | null
+  authenticated_at: string | Date
+  last_seen_at: string | Date
+  expires_at: string | Date
+  revoked_at: string | Date | null
+  created_at: string | Date
+}
+
+function toSession(row: RawSession): AdminSessionRecord {
+  return {
+    id: Number(row.id),
+    userId: Number(row.user_id),
+    ipPrefix: row.ip_prefix,
+    authenticatedAt: toDate(row.authenticated_at),
+    lastSeenAt: toDate(row.last_seen_at),
+    expiresAt: toDate(row.expires_at),
+    revokedAt: toNullableDate(row.revoked_at),
+    createdAt: toDate(row.created_at),
+  }
+}
+
+const SESSION_COLUMNS = sql`
+  id, user_id, ip_prefix, authenticated_at, last_seen_at,
+  expires_at, revoked_at, created_at
+`
+
+export class PostgresAdminSessionRepository implements AdminSessionRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(input: {
+    readonly userId: number
+    readonly tokenHash: string
+    readonly ipPrefix: string | null
+    readonly expiresAt: Date
+    readonly at: Date
+  }): Promise<AdminSessionRecord> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into admin_sessions
+               (user_id, token_hash, ip_prefix, authenticated_at, last_seen_at,
+                expires_at, created_at)
+        values (${input.userId}, ${input.tokenHash}, ${input.ipPrefix}, ${input.at},
+                ${input.at}, ${input.expiresAt}, ${input.at})
+        returning ${SESSION_COLUMNS}
+      `),
+    ) as RawSession[]
+
+    if (rows[0] === undefined) throw new Error('Admin session insert returned no row')
+    return toSession(rows[0])
+  }
+
+  async findLive(tokenHash: string, now: Date): Promise<AdminSessionRecord | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select ${SESSION_COLUMNS}
+          from admin_sessions
+         where token_hash = ${tokenHash}
+           and revoked_at is null
+           and expires_at > ${now}
+      `),
+    ) as RawSession[]
+
+    return rows[0] === undefined ? null : toSession(rows[0])
+  }
+
+  async touch(sessionId: number, now: Date, expiresAt: Date, windowSeconds: number): Promise<void> {
+    const cutoff = new Date(now.getTime() - windowSeconds * 1000)
+    await this.db.execute(sql`
+      update admin_sessions
+         set last_seen_at = ${now}, expires_at = ${expiresAt}
+       where id = ${sessionId}
+         and revoked_at is null
+         and last_seen_at < ${cutoff}
+    `)
+  }
+
+  async markReauthenticated(sessionId: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update admin_sessions
+         set authenticated_at = ${at}, last_seen_at = ${at}
+       where id = ${sessionId} and revoked_at is null
+    `)
+  }
+
+  async revoke(sessionId: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update admin_sessions set revoked_at = ${at}
+       where id = ${sessionId} and revoked_at is null
+    `)
+  }
+
+  async revokeAllForUser(userId: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update admin_sessions set revoked_at = ${at}
+       where user_id = ${userId} and revoked_at is null
+    `)
+  }
+}
+
+export const ACTION_FILTER_LIMIT = 1_000
+
+export class PostgresAdminLogRepository implements AdminLogRepository {
+  constructor(private readonly db: Database) {}
+
+  async record(input: {
+    readonly userId: number | null
+    readonly action: string
+    readonly detail: Readonly<Record<string, unknown>>
+    readonly ipPrefix: string | null
+    readonly at: Date
+  }): Promise<void> {
+    await this.db.execute(sql`
+      insert into admin_log (user_id, action, detail, ip_prefix, created_at)
+      values (${input.userId}, ${input.action}, ${JSON.stringify(input.detail)}::jsonb,
+              ${input.ipPrefix}, ${input.at})
+    `)
+  }
+
+  async list(input: {
+    readonly limit: number
+    readonly offset?: number | undefined
+    readonly before?: number | undefined
+    readonly action?: string | undefined
+  }): Promise<readonly AdminLogRow[]> {
+    const before = input.before === undefined ? sql`` : sql`and l.id < ${input.before}`
+    const action =
+      input.action === undefined || input.action === ''
+        ? sql``
+        : sql`and l.action = ${input.action}`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select l.id, l.user_id, l.action, l.detail, l.ip_prefix, l.created_at,
+               u.username
+          from admin_log l
+          left join users u on u.id = l.user_id
+         where true ${before} ${action}
+         order by l.id desc
+         limit ${input.limit} offset ${input.offset ?? 0}
+      `),
+    ) as Array<{
+      id: number
+      user_id: number | null
+      action: string
+      detail: unknown
+      ip_prefix: string | null
+      created_at: string | Date
+      username: string | null
+    }>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      userId: row.user_id === null ? null : Number(row.user_id),
+      username: row.username,
+      action: row.action,
+      detail:
+        typeof row.detail === 'object' && row.detail !== null && !Array.isArray(row.detail)
+          ? (row.detail as Record<string, unknown>)
+          : {},
+      ipPrefix: row.ip_prefix,
+      createdAt: toDate(row.created_at),
+    }))
+  }
+
+  async count(input: { readonly action?: string | undefined }): Promise<number> {
+    const action =
+      input.action === undefined || input.action === ''
+        ? sql``
+        : sql`and l.action = ${input.action}`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as total from admin_log l where true ${action}
+      `),
+    ) as Array<{ total: number }>
+
+    return Number(rows[0]?.total ?? 0)
+  }
+
+  async actions(limit = ACTION_FILTER_LIMIT): Promise<readonly string[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select distinct action from admin_log order by action limit ${limit}
+      `),
+    ) as Array<{ action: string }>
+
+    return rows.map((row) => row.action)
+  }
+}

package/src/admin-undo-repo.ts

@@ -0,0 +1,128 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate, toNullableDate } from './row-values'
+
+export const ADMIN_UNDO_MAX_SNAPSHOT_BYTES = 64 * 1024
+
+export interface AdminUndoOperation {
+  readonly id: number
+  readonly actorUserId: number
+  readonly operation: string
+  readonly snapshot: Readonly<Record<string, unknown>>
+  readonly createdAt: Date
+  readonly expiresAt: Date
+  readonly consumedAt: Date | null
+}
+
+interface RawUndoOperation {
+  id: number
+  actor_user_id: number
+  operation: string
+  snapshot: unknown
+  created_at: string | Date
+  expires_at: string | Date
+  consumed_at: string | Date | null
+}
+
+function mapped(row: RawUndoOperation): AdminUndoOperation {
+  const snapshot =
+    typeof row.snapshot === 'object' && row.snapshot !== null && !Array.isArray(row.snapshot)
+      ? (row.snapshot as Record<string, unknown>)
+      : {}
+
+  return {
+    id: Number(row.id),
+    actorUserId: Number(row.actor_user_id),
+    operation: row.operation,
+    snapshot,
+    createdAt: toDate(row.created_at),
+    expiresAt: toDate(row.expires_at),
+    consumedAt: toNullableDate(row.consumed_at),
+  }
+}
+
+const COLUMNS = sql`
+  id, actor_user_id, operation, snapshot, created_at, expires_at, consumed_at
+`
+
+export class PostgresAdminUndoRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(input: {
+    readonly tokenHash: string
+    readonly actorUserId: number
+    readonly operation: string
+    readonly snapshot: Readonly<Record<string, unknown>>
+    readonly createdAt: Date
+    readonly expiresAt: Date
+  }): Promise<void> {
+    const encoded = JSON.stringify(input.snapshot)
+    if (Buffer.byteLength(encoded, 'utf8') > ADMIN_UNDO_MAX_SNAPSHOT_BYTES) {
+      throw new RangeError('admin_undo_snapshot_limit')
+    }
+
+    await this.db.execute(sql`
+      insert into admin_undo_operations
+             (token_hash, actor_user_id, operation, snapshot, created_at, expires_at)
+      values (${input.tokenHash}, ${input.actorUserId}, ${input.operation},
+              ${encoded}::jsonb, ${input.createdAt}, ${input.expiresAt})
+    `)
+  }
+
+  async findLive(input: {
+    readonly tokenHash: string
+    readonly actorUserId: number
+    readonly now: Date
+  }): Promise<AdminUndoOperation | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select ${COLUMNS}
+          from admin_undo_operations
+         where token_hash = ${input.tokenHash}
+           and actor_user_id = ${input.actorUserId}
+           and consumed_at is null
+           and expires_at > ${input.now}
+      `),
+    ) as RawUndoOperation[]
+
+    return rows[0] === undefined ? null : mapped(rows[0])
+  }
+
+  async claim(input: {
+    readonly tokenHash: string
+    readonly actorUserId: number
+    readonly now: Date
+  }): Promise<AdminUndoOperation | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update admin_undo_operations
+           set consumed_at = ${input.now}
+         where token_hash = ${input.tokenHash}
+           and actor_user_id = ${input.actorUserId}
+           and consumed_at is null
+           and expires_at > ${input.now}
+        returning ${COLUMNS}
+      `),
+    ) as RawUndoOperation[]
+
+    return rows[0] === undefined ? null : mapped(rows[0])
+  }
+
+  async removeExpired(now: Date, limit = 500): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from admin_undo_operations
+         where id in (
+           select id from admin_undo_operations
+            where expires_at <= ${now}
+            order by expires_at
+            limit ${limit}
+         )
+        returning id
+      `),
+    )
+    return rows.length
+  }
+}

package/src/announcement-repo.ts

@@ -0,0 +1,176 @@
+import { sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import { BodyFormat, sourceAsMarkdown } from '@meith/markdown'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export interface AnnouncementRow {
+  readonly id: number
+  readonly forumId: number | null
+  readonly forumTitle: string | null
+  readonly forumSlug: string | null
+  readonly title: string
+  readonly message: string
+  readonly authorUserId: number | null
+  readonly authorUsername: string
+  readonly startsAt: Date
+  readonly endsAt: Date | null
+  readonly enabled: boolean
+  readonly createdAt: Date
+}
+
+export interface AnnouncementInput {
+  readonly forumId: number | null
+  readonly title: string
+  readonly message: string
+  readonly startsAt: Date
+  readonly endsAt: Date | null
+  readonly enabled: boolean
+}
+
+function toRow(row: Record<string, unknown>): AnnouncementRow {
+  return {
+    id: Number(row.id),
+    forumId: row.forum_id === null ? null : Number(row.forum_id),
+    forumTitle:
+      row.forum_title === null || row.forum_title === undefined ? null : String(row.forum_title),
+    forumSlug:
+      row.forum_slug === null || row.forum_slug === undefined ? null : String(row.forum_slug),
+    title: String(row.title),
+    message: sourceAsMarkdown(String(row.message), Number(row.body_format ?? BodyFormat.Markdown)),
+    authorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+    authorUsername: String(row.author_username),
+    startsAt: new Date(String(row.starts_at)),
+    endsAt: row.ends_at === null ? null : new Date(String(row.ends_at)),
+    enabled: row.enabled === true,
+    createdAt: new Date(String(row.created_at)),
+  }
+}
+
+export class PostgresAnnouncementRepository {
+  constructor(private readonly db: Database) {}
+
+  async live(input: {
+    readonly now: Date
+    readonly visibleForumIds: readonly number[]
+    readonly scope?: number | null
+  }): Promise<readonly AnnouncementRow[]> {
+    const scope = input.scope ?? null
+
+    const visible = sql`${sql.raw('ARRAY[')}${
+      input.visibleForumIds.length === 0
+        ? sql.raw('')
+        : sql.join(
+            input.visibleForumIds.map((id) => sql`${id}`),
+            sql`, `,
+          )
+    }${sql.raw(']::int[]')}`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select a.id, a.forum_id, a.title, a.message, a.body_format, a.author_user_id,
+               a.author_username, a.starts_at, a.ends_at, a.enabled, a.created_at,
+               f.title as forum_title, f.slug as forum_slug
+          from announcements a
+          left join forums f on f.id = a.forum_id
+         where a.enabled
+           and a.starts_at <= ${input.now}
+           and (a.ends_at is null or a.ends_at > ${input.now})
+           and (
+                 a.forum_id is null
+                 or (a.forum_id = ${scope} and a.forum_id = any(${visible}))
+               )
+         order by a.starts_at desc, a.id desc
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map(toRow)
+  }
+
+  async list(): Promise<readonly AnnouncementRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select a.id, a.forum_id, a.title, a.message, a.body_format, a.author_user_id,
+               a.author_username, a.starts_at, a.ends_at, a.enabled, a.created_at,
+               f.title as forum_title, f.slug as forum_slug
+          from announcements a
+          left join forums f on f.id = a.forum_id
+         order by a.starts_at desc, a.id desc
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map(toRow)
+  }
+
+  async find(id: number): Promise<AnnouncementRow | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select a.id, a.forum_id, a.title, a.message, a.body_format, a.author_user_id,
+               a.author_username, a.starts_at, a.ends_at, a.enabled, a.created_at,
+               f.title as forum_title, f.slug as forum_slug
+          from announcements a
+          left join forums f on f.id = a.forum_id
+         where a.id = ${id}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    return row === undefined ? null : toRow(row)
+  }
+
+  async create(
+    input: AnnouncementInput & { readonly authorUserId: number | null },
+  ): Promise<number> {
+    assertValid(input)
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into announcements (forum_id, title, message, body_format,
+                                   author_user_id, author_username, starts_at,
+                                   ends_at, enabled)
+        values (${input.forumId}, ${input.title}, ${input.message},
+                ${BodyFormat.Markdown}, ${input.authorUserId},
+                coalesce((select username from users where id = ${input.authorUserId}), ''),
+                ${input.startsAt}, ${input.endsAt}, ${input.enabled})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    return Number(rows[0]?.id)
+  }
+
+  async update(id: number, input: AnnouncementInput): Promise<void> {
+    assertValid(input)
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update announcements
+           set forum_id = ${input.forumId}, title = ${input.title},
+               message = ${input.message}, body_format = ${BodyFormat.Markdown},
+               starts_at = ${input.startsAt},
+               ends_at = ${input.endsAt}, enabled = ${input.enabled}
+         where id = ${id}
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-announcement'))
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.db.execute(sql`delete from announcements where id = ${id}`)
+  }
+}
+
+function assertValid(input: AnnouncementInput): void {
+  if (input.title.trim() === '') throw new ValidationError(msg('error.db.announcement-needs-title'))
+  if (input.message.trim() === '') {
+    throw new ValidationError(msg('error.db.announcement-needs-something'))
+  }
+  if (input.endsAt !== null && input.endsAt <= input.startsAt) {
+    throw new ValidationError(msg('error.db.announcement-finish-before-starts'))
+  }
+}