@meith/db 0.16.0

package/src/user-merge-repo.ts

@@ -0,0 +1,304 @@
+import { 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 { type Tx, withPermissionVersionBump } from './permission-version'
+import { recountReputation } from './reputation-repo'
+import { resultRows } from './result-rows'
+import { BANNED_PREDICATE } from './user-admin-repo'
+import { type DedupeColumn, MERGE_DEDUPE, MERGE_DISCARD, MERGE_REASSIGN } from './user-merge-map'
+import { recalculateWarningPoints } from './warning-repo'
+
+export interface MergePreview {
+  readonly fromUsername: string
+  readonly toUsername: string
+  readonly posts: number
+  readonly threads: number
+  readonly privateMessages: number
+  readonly attachments: number
+  readonly blockedByBan: boolean
+}
+
+export interface MergeChunkResult {
+  readonly moved: number
+  readonly remaining: number
+}
+
+export class PostgresUserMergeRepository {
+  constructor(private readonly db: Database) {}
+
+  async preview(fromUserId: number, toUserId: number): Promise<MergePreview | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select
+          (select username from users where id = ${fromUserId}) as from_username,
+          (select username from users where id = ${toUserId}) as to_username,
+          (select count(*) from posts where author_user_id = ${fromUserId})::int as posts,
+          (select count(*) from threads where author_user_id = ${fromUserId})::int as threads,
+          (select count(*) from private_messages where author_user_id = ${fromUserId})::int
+            as private_messages,
+          (select count(*) from attachments where uploader_user_id = ${fromUserId})::int
+            as attachments,
+          (select count(*) from users u
+            where u.id in (${fromUserId}, ${toUserId})
+              and ${BANNED_PREDICATE})::int as banned
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    if (row === undefined || row.from_username === null || row.to_username === null) {
+      return null
+    }
+
+    return {
+      fromUsername: String(row.from_username),
+      toUsername: String(row.to_username),
+      posts: Number(row.posts),
+      threads: Number(row.threads),
+      privateMessages: Number(row.private_messages),
+      attachments: Number(row.attachments),
+      blockedByBan: Number(row.banned) > 0,
+    }
+  }
+
+  async mergePostsChunk(
+    fromUserId: number,
+    toUserId: number,
+    limit: number,
+  ): Promise<MergeChunkResult> {
+    assertDistinct(fromUserId, toUserId)
+
+    const moved = resultRows(
+      await this.db.execute(sql`
+        update posts
+           set author_user_id = ${toUserId}
+         where id in (
+           select id from posts where author_user_id = ${fromUserId} order by id limit ${limit}
+         )
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    const remaining = resultRows(
+      await this.db.execute(
+        sql`select count(*)::int as n from posts where author_user_id = ${fromUserId}`,
+      ),
+    ) as Array<{ n: number }>
+
+    return { moved: moved.length, remaining: Number(remaining[0]?.n ?? 0) }
+  }
+
+  async finish(fromUserId: number, toUserId: number): Promise<void> {
+    assertDistinct(fromUserId, toUserId)
+
+    await withPermissionVersionBump(this.db, async (tx) => {
+      const state = resultRows(
+        await tx.execute(sql`
+          select
+            (select count(*) from users where id in (${fromUserId}, ${toUserId}))::int as found,
+            (select count(*) from users u
+              where u.id in (${fromUserId}, ${toUserId})
+                and ${BANNED_PREDICATE})::int as banned,
+            (select count(*) from posts where author_user_id = ${fromUserId})::int as posts
+        `),
+      ) as Array<Record<string, unknown>>
+
+      const row = state[0] as Record<string, unknown>
+      if (Number(row.found) !== 2) throw new ValidationError(msg('error.db.such-member'))
+      if (Number(row.banned) > 0) {
+        throw new ValidationError(msg('error.db.one-these-accounts-banned-lift'))
+      }
+      if (Number(row.posts) > 0) {
+        throw new ValidationError(msg('error.db.there-still-posts-move-finish'))
+      }
+
+      for (const entry of MERGE_DISCARD) {
+        await tx.execute(sql`
+          delete from ${sql.raw(entry.table)}
+           where ${sql.raw(entry.column)} = ${fromUserId}
+        `)
+      }
+
+      for (const entry of MERGE_DEDUPE) {
+        await dedupeThenMove(tx, entry, fromUserId, toUserId)
+      }
+
+      const rated = await mergeBespoke(tx, fromUserId, toUserId)
+
+      for (const entry of MERGE_REASSIGN) {
+        await tx.execute(sql`
+          update ${sql.raw(entry.table)}
+             set ${sql.raw(entry.column)} = ${toUserId}
+           where ${sql.raw(entry.column)} = ${fromUserId}
+        `)
+      }
+
+      const winner = resultRows(
+        await tx.execute(sql`select username from users where id = ${toUserId}`),
+      ) as Array<{ username: string }>
+      const username = winner[0]?.username
+      if (username === undefined) throw new ValidationError(msg('error.db.such-member'))
+
+      await rewriteDenormalisedUsernames(tx, toUserId, username)
+
+      await tx.execute(sql`
+        update users w
+           set post_count = w.post_count + l.post_count,
+               thread_count = w.thread_count + l.thread_count,
+               updated_at = now()
+          from users l
+         where w.id = ${toUserId} and l.id = ${fromUserId}
+      `)
+
+      const rerate = new Set(rated)
+      rerate.add(toUserId)
+      rerate.delete(fromUserId)
+      await recountReputation(tx, [...rerate])
+
+      await recalculateWarningPoints(tx, toUserId)
+      await recalculateWarningPoints(tx, fromUserId)
+
+      await tx.execute(sql`
+        update remember_tokens
+           set revoked_at = now(), revoked_reason = 'account_merge'
+         where user_id in (${fromUserId}, ${toUserId}) and revoked_at is null
+      `)
+
+      await tx.execute(sql`
+        update sessions
+           set revoked_at = now()
+         where user_id in (${fromUserId}, ${toUserId}) and revoked_at is null
+      `)
+
+      await tx.execute(sql`
+        update users
+           set deleted_at = now(), post_count = 0, thread_count = 0, reputation = 0,
+               updated_at = now()
+         where id = ${fromUserId}
+      `)
+    })
+  }
+}
+
+function assertDistinct(fromUserId: number, toUserId: number): void {
+  if (fromUserId === toUserId) {
+    throw new ValidationError(msg('error.db.choose-two-different-accounts'))
+  }
+}
+
+async function dedupeThenMove(
+  tx: Tx,
+  entry: DedupeColumn,
+  fromUserId: number,
+  toUserId: number,
+): Promise<void> {
+  const predicate = entry.where === undefined ? sql`` : sql` and ${sql.raw(entry.where)}`
+  const matches = entry.keys.map(
+    (key) => sql`loser.${sql.raw(key)} is not distinct from winner.${sql.raw(key)}`,
+  )
+
+  await tx.execute(sql`
+    delete from ${sql.raw(entry.table)} loser
+     where loser.${sql.raw(entry.column)} = ${fromUserId}${predicate}
+       and exists (
+         select 1 from ${sql.raw(entry.table)} winner
+          where winner.${sql.raw(entry.column)} = ${toUserId}
+            and ${sql.join(matches, sql` and `)}
+       )
+  `)
+
+  await tx.execute(sql`
+    update ${sql.raw(entry.table)}
+       set ${sql.raw(entry.column)} = ${toUserId}
+     where ${sql.raw(entry.column)} = ${fromUserId}
+  `)
+}
+
+async function mergeBespoke(
+  tx: Tx,
+  fromUserId: number,
+  toUserId: number,
+): Promise<readonly number[]> {
+  const rated = new Set<number>()
+
+  const deleteRatings = async (query: ReturnType<typeof sql>): Promise<void> => {
+    const rows = resultRows(await tx.execute(query)) as Array<{ user_id: number }>
+    for (const row of rows) rated.add(Number(row.user_id))
+  }
+
+  await deleteRatings(sql`
+    delete from reputation
+     where (given_by_user_id = ${fromUserId} and user_id = ${toUserId})
+        or (given_by_user_id = ${toUserId} and user_id = ${fromUserId})
+        or (given_by_user_id = ${fromUserId} and user_id = ${fromUserId})
+    returning user_id
+  `)
+
+  await deleteRatings(sql`
+    delete from reputation loser
+     where loser.given_by_user_id = ${fromUserId}
+       and exists (
+         select 1 from reputation winner
+          where winner.given_by_user_id = ${toUserId}
+            and winner.post_id is not distinct from loser.post_id
+            and winner.user_id is not distinct from loser.user_id
+       )
+    returning loser.user_id
+  `)
+  await tx.execute(sql`
+    update reputation set given_by_user_id = ${toUserId}
+     where given_by_user_id = ${fromUserId}
+  `)
+  await deleteRatings(sql`
+    delete from reputation loser
+     where loser.user_id = ${fromUserId}
+       and exists (
+         select 1 from reputation winner
+          where winner.user_id = ${toUserId}
+            and winner.given_by_user_id = loser.given_by_user_id
+            and winner.post_id is not distinct from loser.post_id
+       )
+    returning loser.user_id
+  `)
+  await tx.execute(sql`
+    update reputation set user_id = ${toUserId} where user_id = ${fromUserId}
+  `)
+
+  await tx.execute(sql`
+    delete from user_relations
+     where (user_id = ${fromUserId} and other_user_id = ${toUserId})
+        or (user_id = ${toUserId} and other_user_id = ${fromUserId})
+        or (user_id = ${fromUserId} and other_user_id = ${fromUserId})
+  `)
+
+  await tx.execute(sql`
+    delete from user_relations loser
+     where loser.user_id = ${fromUserId}
+       and exists (
+         select 1 from user_relations winner
+          where winner.user_id = ${toUserId}
+            and winner.other_user_id = loser.other_user_id
+       )
+  `)
+  await tx.execute(sql`
+    update user_relations set user_id = ${toUserId} where user_id = ${fromUserId}
+  `)
+
+  await tx.execute(sql`
+    delete from user_relations loser
+     where loser.other_user_id = ${fromUserId}
+       and exists (
+         select 1 from user_relations winner
+          where winner.other_user_id = ${toUserId}
+            and winner.user_id = loser.user_id
+       )
+  `)
+  await tx.execute(sql`
+    update user_relations set other_user_id = ${toUserId} where other_user_id = ${fromUserId}
+  `)
+
+  return [...rated]
+}

package/src/visibility-counters.ts

@@ -0,0 +1,190 @@
+import type { SQLWrapper } from 'drizzle-orm'
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+interface CounterTransaction {
+  execute(query: SQLWrapper): Promise<unknown>
+}
+
+export interface VisibilityChange {
+  readonly postId: number
+  readonly threadId: number
+  readonly forumId: number
+  readonly authorId: number | null
+  readonly isFirstPost: boolean
+  readonly delta: 1 | -1
+}
+
+export async function repairThreadLastPost(
+  tx: CounterTransaction,
+  threadId: number,
+): Promise<void> {
+  await tx.execute(sql`
+    with newest as (
+      select id, author_user_id, author_username, created_at
+        from posts
+       where thread_id = ${threadId} and visibility = 'visible'
+       order by id desc
+       limit 1
+    )
+    update threads t
+       set last_post_id = (select id from newest),
+           last_post_user_id = (select author_user_id from newest),
+           last_post_username = (select author_username from newest),
+           last_post_at = coalesce((select created_at from newest), t.created_at),
+           updated_at = now()
+     where t.id = ${threadId}
+  `)
+}
+
+export async function repairForumLastPostChain(
+  tx: CounterTransaction,
+  forumId: number,
+): Promise<void> {
+  const chain = resultRows(
+    await tx.execute(sql`
+      select f.id
+        from forums f
+        join forums child on child.id = ${forumId}
+       where f.id = child.id or child.path like f.path || '.%'
+       order by f.depth desc
+    `),
+  ) as Array<{ id: number }>
+
+  for (const forum of chain) {
+    await tx.execute(sql`
+      with own as (
+        select t.last_post_id as post_id, t.last_post_at as at, t.id as thread_id,
+               t.title as thread_title, t.last_post_user_id as user_id,
+               t.last_post_username as username
+          from threads t
+         where t.forum_id = ${forum.id}
+           and t.visibility = 'visible'
+           and t.last_post_id is not null
+         order by t.last_post_at desc, t.last_post_id desc
+         limit 1
+      ),
+      kid as (
+        select c.last_post_id as post_id, c.last_post_at as at,
+               c.last_post_thread_id as thread_id, c.last_post_thread_title as thread_title,
+               c.last_post_user_id as user_id, c.last_post_username as username
+          from forums c
+         where c.parent_id = ${forum.id} and c.last_post_id is not null
+         order by c.last_post_at desc, c.last_post_id desc
+         limit 1
+      ),
+      best as (
+        select * from (select * from own union all select * from kid) candidates
+         order by at desc, post_id desc
+         limit 1
+      )
+      update forums f
+         set last_post_id = (select post_id from best),
+             last_post_thread_id = (select thread_id from best),
+             last_post_thread_title = (select thread_title from best),
+             last_post_user_id = (select user_id from best),
+             last_post_username = (select username from best),
+             last_post_at = (select at from best),
+             updated_at = now()
+       where f.id = ${forum.id}
+    `)
+  }
+}
+
+export async function applyVisibilityChangeCounters(
+  tx: CounterTransaction,
+  change: VisibilityChange,
+): Promise<void> {
+  const threadDelta = change.isFirstPost ? change.delta : 0
+  const replyDelta = change.isFirstPost ? 0 : change.delta
+
+  await tx.execute(sql`
+    update forums
+       set post_count = greatest(post_count + ${change.delta}, 0),
+           thread_count = greatest(thread_count + ${threadDelta}, 0),
+           updated_at = now()
+     where id = ${change.forumId}
+  `)
+
+  await tx.execute(sql`
+    update threads
+       set reply_count = greatest(reply_count + ${replyDelta}, 0),
+           updated_at = now()
+     where id = ${change.threadId}
+  `)
+
+  if (change.authorId !== null) {
+    await tx.execute(sql`
+      update users
+         set post_count = greatest(post_count + ${change.delta}, 0),
+             thread_count = greatest(thread_count + ${threadDelta}, 0),
+             updated_at = now()
+       where id = ${change.authorId}
+    `)
+  }
+
+  await repairThreadLastPost(tx, change.threadId)
+  await repairForumLastPostChain(tx, change.forumId)
+
+  await tx.execute(sql`
+    insert into outbox (topic, payload)
+    values (
+      'post.visibility_changed',
+      ${JSON.stringify({
+        postId: change.postId,
+        threadId: change.threadId,
+        forumId: change.forumId,
+        visible: change.delta === 1,
+      })}::jsonb
+    )
+  `)
+}
+
+export async function applyAncestorVisibilityChange(
+  db: Database,
+  postId: number,
+): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const found = resultRows(
+      await tx.execute(sql`
+        select visibility, forum_id, is_first_post from posts where id = ${postId}
+      `),
+    ) as Array<{ visibility: string; forum_id: number; is_first_post: boolean }>
+
+    const post = found[0]
+    if (!post) return false
+
+    const shouldCount = post.visibility === 'visible'
+    if (shouldCount) {
+      const claimed = await tx.execute(sql`
+        insert into content_counter_rollups (post_id) values (${postId})
+        on conflict (post_id) do nothing
+        returning post_id
+      `)
+      if (resultRows(claimed).length === 0) return false
+    } else {
+      const released = await tx.execute(sql`
+        delete from content_counter_rollups where post_id = ${postId} returning post_id
+      `)
+      if (resultRows(released).length === 0) return false
+    }
+
+    const delta = shouldCount ? 1 : -1
+    const threadDelta = post.is_first_post ? delta : 0
+
+    await tx.execute(sql`
+      update forums f
+         set post_count = greatest(f.post_count + ${delta}, 0),
+             thread_count = greatest(f.thread_count + ${threadDelta}, 0),
+             updated_at = now()
+        from forums child
+       where child.id = ${post.forum_id}
+         and f.id <> child.id
+         and child.path like f.path || '.%'
+    `)
+
+    return true
+  })
+}

package/src/visibility.ts

@@ -0,0 +1,17 @@
+import { type SQL, sql } from 'drizzle-orm'
+import type { PgColumn } from 'drizzle-orm/pg-core'
+
+import type { ContentScope } from '@meith/core'
+
+export function visibleIn(column: PgColumn | SQL, scope: ContentScope): SQL {
+  const first = scope.states[0]
+  if (scope.states.length === 1) return sql`${column} = ${first}`
+  return sql`${column} in (${sql.join(
+    scope.states.map((state) => sql`${state}`),
+    sql`, `,
+  )})`
+}
+
+export const PENDING_APPROVAL = 'unapproved' as const
+
+export const VISIBLE = 'visible' as const

package/src/vocabulary-repo.ts

@@ -0,0 +1,54 @@
+import { sql } from 'drizzle-orm'
+
+import {
+  type BoardVocabulary,
+  CORE_RENDERING,
+  compileVocabulary,
+  type MarkdownPipeline,
+  NO_VOCABULARY_SOURCE,
+  type VocabularySource,
+} from '@meith/markdown'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export async function readVocabularySource(db: Database): Promise<VocabularySource | null> {
+  return db.transaction(async (tx) => {
+    const revision = resultRows(
+      await tx.execute(sql`select version from cache_versions where key = 'markdown_vocabulary'`),
+    ) as Array<{ version: number }>
+
+    if (Number(revision[0]?.version ?? 0) === 0) return null
+
+    const smilies = resultRows(
+      await tx.execute(sql`select code, src, alt from smilies where enabled = true order by id`),
+    ) as Array<Record<string, unknown>>
+
+    const directives = resultRows(
+      await tx.execute(
+        sql`select name, block from custom_directives where enabled = true order by name`,
+      ),
+    ) as Array<Record<string, unknown>>
+
+    return {
+      revision: Number(revision[0]?.version ?? 0),
+      smilies: smilies.map((row) => ({
+        code: String(row.code),
+        src: String(row.src),
+        ...(row.alt === null ? {} : { alt: String(row.alt) }),
+      })),
+      directives: directives.map((row) => ({
+        name: String(row.name),
+        block: row.block === true,
+      })),
+    }
+  })
+}
+
+export async function readBoardVocabulary(
+  db: Database,
+  pipeline: MarkdownPipeline = CORE_RENDERING,
+): Promise<BoardVocabulary> {
+  const source = await pipeline.vocabulary((await readVocabularySource(db)) ?? NO_VOCABULARY_SOURCE)
+  return compileVocabulary(source)
+}