@meith/db 0.16.0

package/src/modcp-repo.ts

@@ -0,0 +1,253 @@
+import { type SQL, sql } from 'drizzle-orm'
+
+import type { IpMatch, ModCpRepository, ModLogEntry, ModLogPage } from '@meith/moderation'
+import { MOD_LOG_ACTIONS } from '@meith/moderation'
+
+import type { Database } from './client'
+import { decodeCursor, encodeCursor } from './cursor'
+import { resultRows } from './result-rows'
+import { idList, textList } from './sql-lists'
+import { PENDING_APPROVAL } from './visibility'
+
+interface LogRow {
+  id: number
+  action: string
+  user_id: number | null
+  username: string | null
+  forum_id: number | null
+  forum_title: string | null
+  detail: Record<string, unknown> | null
+  created_at: Date
+}
+
+const DETAIL_LABELS: Readonly<Record<string, string>> = {
+  threadId: 'Thread',
+  threadIds: 'Threads',
+  targetThreadId: 'Into thread',
+  newThreadId: 'New thread',
+  postId: 'Post',
+  postIds: 'Posts',
+  forumId: 'Forum',
+  fromForumId: 'From forum',
+  toForumId: 'To forum',
+  applied: 'Applied to',
+  posts: 'Posts affected',
+  userId: 'Member',
+  warningId: 'Warning',
+  points: 'Points',
+  total: 'New total',
+  matches: 'Accounts found',
+  subjectUserId: 'Member',
+  reportId: 'Report',
+  value: 'Set to',
+}
+
+function flattenDetail(
+  detail: Record<string, unknown> | null,
+): readonly { label: string; value: string }[] {
+  if (detail === null) return []
+  const out: { label: string; value: string }[] = []
+  for (const [key, label] of Object.entries(DETAIL_LABELS)) {
+    const value = detail[key]
+    if (value === undefined || value === null) continue
+    const rendered = Array.isArray(value)
+      ? value.slice(0, 20).map(String).join(', ')
+      : String(value)
+    if (rendered === '') continue
+    out.push({ label, value: rendered })
+  }
+  return out
+}
+
+function forumScope(forumIds: readonly number[]): SQL {
+  if (forumIds.length === 0) return sql`false`
+  return sql.join(
+    forumIds.map(
+      (id) => sql`(
+        l.detail->'forumIds' @> ${String(id)}::jsonb
+        or l.detail->'forumId' = ${String(id)}::jsonb
+        or l.detail->'toForumId' = ${String(id)}::jsonb
+      )`,
+    ),
+    sql` or `,
+  )
+}
+
+export class PostgresModCpRepository implements ModCpRepository {
+  constructor(private readonly db: Database) {}
+
+  async log(input: {
+    readonly forumIds: readonly number[]
+    readonly actorUserId: number
+    readonly limit: number
+    readonly after?: string | undefined
+  }): Promise<ModLogPage> {
+    const cursor = input.after === undefined ? null : decodeCursor(input.after)
+    const after = cursor ? sql`and (e.created_at, e.id) < (${cursor.at}, ${cursor.id})` : sql``
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        with entry as (
+          select l.id, l.action, l.user_id, l.created_at, l.detail,
+                 coalesce(
+                   (l.detail->>'forumId')::int,
+                   (l.detail->>'toForumId')::int
+                 ) as forum_id
+            from admin_log l
+           where l.action in ${textList(MOD_LOG_ACTIONS)}
+             and (
+                   l.user_id = ${input.actorUserId}
+                   or ${forumScope(input.forumIds)}
+                 )
+        )
+        select e.id, e.action, e.user_id, u.username, e.forum_id,
+               f.title as forum_title, e.detail, e.created_at
+          from entry e
+          left join users u on u.id = e.user_id
+          left join forums f on f.id = e.forum_id
+         where true ${after}
+         order by e.created_at desc, e.id desc
+         limit ${input.limit + 1}
+      `),
+    ) as LogRow[]
+
+    const entries = rows.slice(0, input.limit).map(
+      (row): ModLogEntry => ({
+        id: Number(row.id),
+        action: row.action,
+        actorUserId: row.user_id === null ? null : Number(row.user_id),
+        actorUsername: row.username,
+        forumId: row.forum_id === null ? null : Number(row.forum_id),
+        forumTitle: row.forum_title,
+        detail: flattenDetail(row.detail),
+        at: new Date(row.created_at),
+      }),
+    )
+    const last = entries.at(-1)
+    return rows.length > input.limit && last
+      ? { entries, nextCursor: encodeCursor(last.at, last.id) }
+      : { entries }
+  }
+
+  async workload(
+    forumIds: readonly number[],
+  ): Promise<ReadonlyMap<number, { pending: number; openReports: number }>> {
+    if (forumIds.length === 0) return new Map()
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        with held as (
+          select forum_id, count(*)::int as n from threads
+           where forum_id in ${idList(forumIds)} and visibility = ${PENDING_APPROVAL}
+           group by forum_id
+          union all
+          select p.forum_id, count(*)::int from posts p
+            join threads t on t.id = p.thread_id
+           where p.forum_id in ${idList(forumIds)}
+             and p.visibility = ${PENDING_APPROVAL}
+             and t.visibility <> ${PENDING_APPROVAL}
+             and p.is_first_post = false
+           group by p.forum_id
+        ),
+        reported as (
+          select forum_id, count(*)::int as n from reports
+           where forum_id in ${idList(forumIds)} and status = 'open'
+           group by forum_id
+        )
+        select f.id as forum_id,
+               coalesce((select sum(n) from held where held.forum_id = f.id), 0)::int as pending,
+               coalesce((select n from reported where reported.forum_id = f.id), 0)::int as open_reports
+          from forums f
+         where f.id in ${idList(forumIds)}
+      `),
+    ) as Array<{ forum_id: number; pending: number; open_reports: number }>
+
+    return new Map(
+      rows.map((row) => [
+        Number(row.forum_id),
+        { pending: Number(row.pending), openReports: Number(row.open_reports) },
+      ]),
+    )
+  }
+
+  async ipPrefixesFor(
+    userId: number,
+  ): Promise<{ registration: string | null; lastVisit: string | null }> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select registration_ip_prefix, last_ip_prefix from users where id = ${userId}
+      `),
+    ) as Array<{ registration_ip_prefix: string | null; last_ip_prefix: string | null }>
+    const row = rows[0]
+    if (!row) return { registration: null, lastVisit: null }
+    return { registration: row.registration_ip_prefix, lastVisit: row.last_ip_prefix }
+  }
+
+  async ipMatches(userId: number, limit: number): Promise<readonly IpMatch[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        with subject as (
+          select registration_ip_prefix as reg, last_ip_prefix as last
+            from users where id = ${userId}
+        )
+        select u.id, u.username, u.last_active_at,
+               (u.registration_ip_prefix is not null
+                 and u.registration_ip_prefix in (
+                   (select reg from subject), (select last from subject)
+                 )) as by_registration,
+               (u.last_ip_prefix is not null
+                 and u.last_ip_prefix in (
+                   (select reg from subject), (select last from subject)
+                 )) as by_last
+          from users u, subject s
+         where u.id <> ${userId}
+           and u.state <> 'deleted'
+           and (
+             (u.registration_ip_prefix is not null
+               and u.registration_ip_prefix in (s.reg, s.last))
+             or (u.last_ip_prefix is not null and u.last_ip_prefix in (s.reg, s.last))
+           )
+         order by u.last_active_at desc nulls last, u.id
+         limit ${limit}
+      `),
+    ) as Array<{
+      id: number
+      username: string
+      last_active_at: Date | null
+      by_registration: boolean
+      by_last: boolean
+    }>
+
+    return rows.map((row) => ({
+      userId: Number(row.id),
+      username: row.username,
+      matchedOn:
+        row.by_registration && row.by_last
+          ? 'both'
+          : row.by_registration
+            ? 'registration'
+            : 'last_visit',
+      lastActiveAt: row.last_active_at === null ? null : new Date(row.last_active_at),
+    }))
+  }
+
+  async recordIpLookup(input: {
+    readonly actorUserId: number
+    readonly subjectUserId: number
+    readonly matches: number
+    readonly at: Date
+  }): Promise<void> {
+    await this.db.execute(sql`
+      insert into admin_log (user_id, action, detail, created_at)
+      values (
+        ${input.actorUserId},
+        'modcp.ip_lookup',
+        ${JSON.stringify({
+          subjectUserId: input.subjectUserId,
+          matches: input.matches,
+        })}::jsonb,
+        ${input.at}
+      )
+    `)
+  }
+}

package/src/moderation-queue.ts

@@ -0,0 +1,279 @@
+import { sql } from 'drizzle-orm'
+
+import type {
+  ModerationQueueRepository,
+  PendingItem,
+  QueueDecision,
+  QueueItem,
+  QueuePage,
+  QueueSelection,
+} from '@meith/moderation'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { idList } from './sql-lists'
+import { PENDING_APPROVAL, VISIBLE } from './visibility'
+import { applyVisibilityChangeCounters } from './visibility-counters'
+
+const EXCERPT = 300
+
+interface QueueRow {
+  kind: 'thread' | 'post'
+  id: number
+  forum_id: number
+  forum_title: string
+  thread_id: number
+  thread_slug: string
+  thread_title: string
+  author_user_id: number | null
+  author_username: string
+  excerpt: string | null
+  created_at: Date
+}
+
+function encodeCursor(row: QueueItem): string {
+  return Buffer.from(`${row.createdAt.toISOString()}|${row.kind}|${row.id}`, 'utf8').toString(
+    'base64url',
+  )
+}
+
+function decodeCursor(value: string): { at: Date; kind: string; id: number } | null {
+  try {
+    const [at, kind, id] = Buffer.from(value, 'base64url').toString('utf8').split('|')
+    if (at === undefined || kind === undefined || id === undefined) return null
+    const when = new Date(at)
+    const numeric = Number(id)
+    if (Number.isNaN(when.getTime()) || !Number.isSafeInteger(numeric)) return null
+    return { at: when, kind, id: numeric }
+  } catch {
+    return null
+  }
+}
+
+function toItem(row: QueueRow): QueueItem {
+  return {
+    kind: row.kind,
+    id: Number(row.id),
+    forumId: Number(row.forum_id),
+    forumTitle: row.forum_title,
+    threadId: Number(row.thread_id),
+    threadSlug: row.thread_slug,
+    threadTitle: row.thread_title,
+    authorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+    authorUsername: row.author_username,
+    excerpt: row.excerpt ?? '',
+    createdAt: new Date(row.created_at),
+  }
+}
+
+export class PostgresModerationQueueRepository implements ModerationQueueRepository {
+  constructor(private readonly db: Database) {}
+
+  async list(
+    forumIds: readonly number[],
+    options: {
+      readonly limit: number
+      readonly after?: string
+      readonly offset?: number
+    },
+  ): Promise<QueuePage> {
+    if (forumIds.length === 0) return { items: [] }
+
+    const cursor = options.after === undefined ? null : decodeCursor(options.after)
+    const after = cursor
+      ? sql`and (q.created_at, q.kind, q.id) > (${cursor.at}, ${cursor.kind}, ${cursor.id})`
+      : sql``
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        with q as (
+          select 'thread'::text as kind, t.id, t.forum_id, f.title as forum_title,
+                 t.id as thread_id, t.slug as thread_slug, t.title as thread_title,
+                 t.author_user_id, t.author_username,
+                 left(p.message, ${EXCERPT}) as excerpt, t.created_at
+            from threads t
+            join forums f on f.id = t.forum_id
+            left join posts p on p.id = t.first_post_id
+           where t.forum_id in ${idList(forumIds)}
+             and t.visibility = ${PENDING_APPROVAL}
+          union all
+          select 'post'::text, p.id, p.forum_id, f.title,
+                 p.thread_id, t.slug, t.title,
+                 p.author_user_id, p.author_username,
+                 left(p.message, ${EXCERPT}), p.created_at
+            from posts p
+            join threads t on t.id = p.thread_id
+            join forums f on f.id = p.forum_id
+           where p.forum_id in ${idList(forumIds)}
+             and p.visibility = ${PENDING_APPROVAL}
+             and t.visibility = ${VISIBLE}
+             and p.is_first_post = false
+        )
+        select * from q
+         where true ${after}
+         order by q.created_at, q.kind, q.id
+         limit ${options.limit + 1} offset ${options.offset ?? 0}
+      `),
+    ) as QueueRow[]
+
+    const items = rows.slice(0, options.limit).map(toItem)
+    const last = items.at(-1)
+    return rows.length > options.limit && last
+      ? { items, nextCursor: encodeCursor(last) }
+      : { items }
+  }
+
+  async countPending(forumIds: readonly number[]): Promise<number> {
+    if (forumIds.length === 0) return 0
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select
+          (select count(*) from threads
+            where forum_id in ${idList(forumIds)} and visibility = ${PENDING_APPROVAL})
+          +
+          (select count(*) from posts p
+             join threads t on t.id = p.thread_id
+            where p.forum_id in ${idList(forumIds)}
+              and p.visibility = ${PENDING_APPROVAL}
+              and t.visibility = ${VISIBLE}
+              and p.is_first_post = false)
+          as pending
+      `),
+    ) as Array<{ pending: number }>
+    return Number(rows[0]?.pending ?? 0)
+  }
+
+  async resolve(selection: readonly QueueSelection[]): Promise<readonly PendingItem[]> {
+    const threadIds = selection.filter((s) => s.kind === 'thread').map((s) => s.id)
+    const postIds = selection.filter((s) => s.kind === 'post').map((s) => s.id)
+    if (threadIds.length === 0 && postIds.length === 0) return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select 'thread'::text as kind, id, forum_id from threads
+         where id in ${idList(threadIds)} and visibility = ${PENDING_APPROVAL}
+        union all
+        select 'post'::text, p.id, p.forum_id from posts p
+          join threads t on t.id = p.thread_id
+         where p.id in ${idList(postIds)}
+           and p.visibility = ${PENDING_APPROVAL}
+           and t.visibility = ${VISIBLE}
+      `),
+    ) as Array<{ kind: 'thread' | 'post'; id: number; forum_id: number }>
+
+    return rows.map((row) => ({
+      kind: row.kind,
+      id: Number(row.id),
+      forumId: Number(row.forum_id),
+    }))
+  }
+
+  async apply(input: {
+    readonly decision: QueueDecision
+    readonly threadIds: readonly number[]
+    readonly postIds: readonly number[]
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<number> {
+    if (input.threadIds.length === 0 && input.postIds.length === 0) return 0
+    const approving = input.decision === 'approve'
+    const to = approving ? 'visible' : 'deleted'
+
+    return this.db.transaction(async (tx) => {
+      let applied = 0
+      const touched = new Set<number>()
+
+      for (const threadId of input.threadIds) {
+        const moved = resultRows(
+          await tx.execute(sql`
+            update threads set visibility = ${to}, updated_at = now()
+             where id = ${threadId} and visibility = ${PENDING_APPROVAL}
+             returning id, forum_id, first_post_id, author_user_id
+          `),
+        ) as Array<{
+          id: number
+          forum_id: number
+          first_post_id: number | null
+          author_user_id: number | null
+        }>
+        const thread = moved[0]
+        if (!thread) continue
+        applied += 1
+        touched.add(Number(thread.forum_id))
+
+        if (thread.first_post_id !== null) {
+          const post = resultRows(
+            await tx.execute(sql`
+              update posts set visibility = ${to}
+               where id = ${thread.first_post_id} and visibility = ${PENDING_APPROVAL}
+               returning id
+            `),
+          ) as Array<{ id: number }>
+
+          if (post[0] && approving) {
+            await applyVisibilityChangeCounters(tx, {
+              postId: Number(post[0].id),
+              threadId: Number(thread.id),
+              forumId: Number(thread.forum_id),
+              authorId: thread.author_user_id === null ? null : Number(thread.author_user_id),
+              isFirstPost: true,
+              delta: 1,
+            })
+          }
+        }
+      }
+
+      for (const postId of input.postIds) {
+        const moved = resultRows(
+          await tx.execute(sql`
+            update posts set visibility = ${to}
+             where id = ${postId} and visibility = ${PENDING_APPROVAL}
+             returning id, thread_id, forum_id, author_user_id, is_first_post
+          `),
+        ) as Array<{
+          id: number
+          thread_id: number
+          forum_id: number
+          author_user_id: number | null
+          is_first_post: boolean
+        }>
+        const post = moved[0]
+        if (!post) continue
+        applied += 1
+        touched.add(Number(post.forum_id))
+
+        if (approving) {
+          await applyVisibilityChangeCounters(tx, {
+            postId: Number(post.id),
+            threadId: Number(post.thread_id),
+            forumId: Number(post.forum_id),
+            authorId: post.author_user_id === null ? null : Number(post.author_user_id),
+            isFirstPost: post.is_first_post,
+            delta: 1,
+          })
+        }
+      }
+
+      if (applied > 0) {
+        const forumIds = [...touched]
+        await tx.execute(sql`
+          insert into admin_log (user_id, action, detail, created_at)
+          values (
+            ${input.actorUserId},
+            ${`moderation.${input.decision}`},
+            ${JSON.stringify({
+              threadIds: input.threadIds,
+              postIds: input.postIds,
+              ...(forumIds.length === 1 ? { forumId: forumIds[0] } : {}),
+              forumIds,
+              applied,
+            })}::jsonb,
+            ${input.at}
+          )
+        `)
+      }
+
+      return applied
+    })
+  }
+}