@meith/db 0.16.0

package/src/thread-tools.ts

@@ -0,0 +1,311 @@
+import { sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import type { MoveDestination, ThreadToolsRepository, ThreadToolTarget } from '@meith/moderation'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import {
+  applyAuthorCounts,
+  applyForumChain,
+  logModeratorAction as log,
+  syncLedger,
+  tallyThread,
+} from './thread-counters'
+import { repairForumLastPostChain, repairThreadLastPost } from './visibility-counters'
+
+export class PostgresThreadToolsRepository implements ThreadToolsRepository {
+  constructor(private readonly db: Database) {}
+
+  async find(threadId: number): Promise<ThreadToolTarget | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, forum_id, slug, title, is_locked, is_sticky, visibility
+          from threads where id = ${threadId}
+      `),
+    ) as Array<{
+      id: number
+      forum_id: number
+      slug: string
+      title: string
+      is_locked: boolean
+      is_sticky: boolean
+      visibility: ThreadToolTarget['visibility']
+    }>
+
+    const row = rows[0]
+    if (!row) return null
+    return {
+      id: Number(row.id),
+      forumId: Number(row.forum_id),
+      slug: row.slug,
+      title: row.title,
+      isLocked: row.is_locked,
+      isSticky: row.is_sticky,
+      visibility: row.visibility,
+    }
+  }
+
+  async findDestination(forumId: number): Promise<MoveDestination | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`select id, type, allow_threads from forums where id = ${forumId}`),
+    ) as Array<{ id: number; type: MoveDestination['type']; allow_threads: boolean }>
+    const row = rows[0]
+    return row === undefined
+      ? null
+      : { id: Number(row.id), type: row.type, allowThreads: row.allow_threads === true }
+  }
+
+  async setLocked(input: {
+    readonly threadId: number
+    readonly locked: boolean
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean> {
+    return this.flag(
+      'is_locked',
+      input.locked,
+      input,
+      input.locked ? 'thread.lock' : 'thread.unlock',
+    )
+  }
+
+  async setSticky(input: {
+    readonly threadId: number
+    readonly sticky: boolean
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean> {
+    return this.flag(
+      'is_sticky',
+      input.sticky,
+      input,
+      input.sticky ? 'thread.stick' : 'thread.unstick',
+    )
+  }
+
+  private async flag(
+    column: 'is_locked' | 'is_sticky',
+    value: boolean,
+    input: { readonly threadId: number; readonly actorUserId: number; readonly at: Date },
+    action: string,
+  ): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const moved = resultRows(
+        await tx.execute(
+          column === 'is_locked'
+            ? sql`update threads set is_locked = ${value}, updated_at = ${input.at}
+                   where id = ${input.threadId} and is_locked <> ${value}
+                   returning id, forum_id`
+            : sql`update threads set is_sticky = ${value}, updated_at = ${input.at}
+                   where id = ${input.threadId} and is_sticky <> ${value}
+                   returning id, forum_id`,
+        ),
+      ) as Array<{ id: number; forum_id: number }>
+      const row = moved[0]
+      if (!row) return false
+
+      const forumId = Number(row.forum_id)
+      await log(
+        tx,
+        action,
+        input.actorUserId,
+        { threadId: input.threadId, forumId, forumIds: [forumId] },
+        input.at,
+      )
+      return true
+    })
+  }
+
+  async setVisibility(input: {
+    readonly threadId: number
+    readonly from: 'visible' | 'deleted'
+    readonly to: 'visible' | 'deleted'
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const tally = await tallyThread(tx, input.threadId)
+
+      const moved = resultRows(
+        await tx.execute(sql`
+          update threads set visibility = ${input.to}, updated_at = ${input.at}
+           where id = ${input.threadId} and visibility = ${input.from}
+           returning forum_id
+        `),
+      ) as Array<{ forum_id: number }>
+      const row = moved[0]
+      if (!row) return false
+
+      const forumId = Number(row.forum_id)
+      const delta: 1 | -1 = input.to === 'visible' ? 1 : -1
+
+      await applyForumChain(tx, forumId, delta, tally)
+      await applyAuthorCounts(tx, delta, tally)
+      await syncLedger(tx, input.threadId, input.to === 'visible')
+      await repairForumLastPostChain(tx, forumId)
+
+      await log(
+        tx,
+        input.to === 'visible' ? 'thread.restore' : 'thread.delete',
+        input.actorUserId,
+        { threadId: input.threadId, forumId, forumIds: [forumId], posts: tally.posts },
+        input.at,
+      )
+      return true
+    })
+  }
+
+  async move(input: {
+    readonly threadId: number
+    readonly fromForumId: number
+    readonly toForumId: number
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const tally = await tallyThread(tx, input.threadId)
+
+      const moved = resultRows(
+        await tx.execute(sql`
+          update threads set forum_id = ${input.toForumId}, updated_at = ${input.at}
+           where id = ${input.threadId} and forum_id = ${input.fromForumId}
+           returning id
+        `),
+      ) as Array<{ id: number }>
+      if (moved.length === 0) return false
+
+      await tx.execute(sql`
+        update posts set forum_id = ${input.toForumId} where thread_id = ${input.threadId}
+      `)
+
+      await applyForumChain(tx, input.fromForumId, -1, tally)
+      await applyForumChain(tx, input.toForumId, 1, tally)
+
+      await repairForumLastPostChain(tx, input.fromForumId)
+      await repairForumLastPostChain(tx, input.toForumId)
+
+      await log(
+        tx,
+        'thread.move',
+        input.actorUserId,
+        {
+          threadId: input.threadId,
+          fromForumId: input.fromForumId,
+          toForumId: input.toForumId,
+          forumIds: [input.fromForumId, input.toForumId],
+          posts: tally.posts,
+        },
+        input.at,
+      )
+      return true
+    })
+  }
+
+  async copy(input: {
+    readonly threadId: number
+    readonly toForumId: number
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<{ threadId: number; slug: string; posts: number }> {
+    return this.db.transaction(async (tx) => {
+      const sourceRows = resultRows(
+        await tx.execute(sql`
+          select id, forum_id, title, slug, prefix_id, author_user_id, author_username
+            from threads where id = ${input.threadId}
+        `),
+      ) as Array<{
+        id: number
+        forum_id: number
+        title: string
+        slug: string
+        prefix_id: number | null
+        author_user_id: number | null
+        author_username: string
+      }>
+      const source = sourceRows[0]
+      if (!source) {
+        throw new ValidationError(msg('error.db.thread-exist'))
+      }
+
+      const created = resultRows(
+        await tx.execute(sql`
+          insert into threads
+            (forum_id, title, slug, prefix_id, author_user_id, author_username,
+             visibility, created_at, updated_at)
+          values
+            (${input.toForumId}, ${source.title}, ${source.slug}, ${source.prefix_id},
+             ${source.author_user_id}, ${source.author_username},
+             'visible', ${input.at}, ${input.at})
+          returning id, slug
+        `),
+      ) as Array<{ id: number; slug: string }>
+      const newThreadId = Number(created[0]!.id)
+
+      const copied = resultRows(
+        await tx.execute(sql`
+          insert into posts
+            (thread_id, forum_id, author_user_id, author_username, subject, message,
+             message_html, render_version, vocab_version, body_format, visibility,
+             is_first_post, created_at, search_vector, search_version)
+          select ${newThreadId}, ${input.toForumId}, p.author_user_id, p.author_username,
+                 p.subject, p.message, p.message_html, p.render_version,
+                 /*
+                  * Both stamps travel with the body. A copy that claimed to be
+                  * Markdown because the column defaults that way would be a post
+                  * whose BBCode the backfill has been told it already converted.
+                  */
+                 p.vocab_version, p.body_format,
+                 'visible', p.is_first_post, p.created_at,
+                 /*
+                  * The search document travels too, for the third time in this list
+                  * and the same reason: a copy left with no vector would be a
+                  * thread nobody could find until the backfill happened to
+                  * reach it. Copying rather than recomputing is exact here —
+                  * the copy keeps the source's title, body and opening post, so
+                  * every input to the document is the same.
+                  */
+                 p.search_vector, p.search_version
+            from posts p
+           where p.thread_id = ${input.threadId} and p.visibility = 'visible'
+           order by p.id
+          returning id, author_user_id, is_first_post
+        `),
+      ) as Array<{ id: number; author_user_id: number | null; is_first_post: boolean }>
+
+      const first = copied.find((row) => row.is_first_post) ?? copied[0]
+      await tx.execute(sql`
+        update threads
+           set first_post_id = ${first === undefined ? null : Number(first.id)},
+               reply_count = ${Math.max(copied.length - 1, 0)}
+         where id = ${newThreadId}
+      `)
+
+      const tally = await tallyThread(tx, newThreadId)
+      await applyForumChain(tx, input.toForumId, 1, tally)
+      await applyAuthorCounts(tx, 1, tally)
+      await syncLedger(tx, newThreadId, true)
+      await repairThreadLastPost(tx, newThreadId)
+      await repairForumLastPostChain(tx, input.toForumId)
+
+      const fromForumId = Number(source.forum_id)
+      await log(
+        tx,
+        'thread.copy',
+        input.actorUserId,
+        {
+          threadId: input.threadId,
+          fromForumId,
+          toForumId: input.toForumId,
+          forumIds: [...new Set([fromForumId, input.toForumId])],
+          newThreadId,
+          posts: copied.length,
+        },
+        input.at,
+      )
+
+      return { threadId: newThreadId, slug: created[0]!.slug, posts: copied.length }
+    })
+  }
+}

package/src/thread-views.ts

@@ -0,0 +1,41 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export class PostgresThreadViewBuffer {
+  constructor(private readonly db: Database) {}
+
+  async record(threadId: number): Promise<void> {
+    await this.db.execute(sql`
+      insert into thread_view_buffer (thread_id, pending, updated_at)
+      values (${threadId}, 1, now())
+      on conflict (thread_id) do update
+        set pending = thread_view_buffer.pending + 1,
+            updated_at = now()
+    `)
+  }
+
+  async flush(limit = 500): Promise<number> {
+    const result = await this.db.execute(sql`
+      with claimed as (
+        delete from thread_view_buffer
+         where thread_id in (
+           select thread_id from thread_view_buffer
+            where pending > 0
+            order by updated_at
+            limit ${limit}
+            for update skip locked
+         )
+        returning thread_id, pending
+      )
+      update threads t
+         set view_count = t.view_count + c.pending
+        from claimed c
+       where t.id = c.thread_id
+      returning t.id
+    `)
+
+    return resultRows(result).length
+  }
+}

package/src/thread-writes.ts

@@ -0,0 +1,356 @@
+import { sql } from 'drizzle-orm'
+
+import {
+  authorRef,
+  BodyFormat,
+  CORE_RENDERING,
+  type MarkdownPipeline,
+  renderThrough,
+  vocabularyOptions,
+} from '@meith/markdown'
+import type { ValidatedPoll } from '@meith/polls'
+import type {
+  CreatedThread,
+  ForumPostingTarget,
+  NewReplyRecord,
+  NewThreadRecord,
+  ReplyTarget,
+  ReplyWriteRepository,
+  ThreadWriteRepository,
+} from '@meith/threads'
+
+import type { Database } from './client'
+import { applyCreatedContentCounters } from './content-counters'
+import { resultRows } from './result-rows'
+import { SEARCH_DOCUMENT_VERSION, searchVectorSql } from './search-repo'
+import { readBoardVocabulary } from './vocabulary-repo'
+
+export class PostgresThreadWriteRepository implements ThreadWriteRepository, ReplyWriteRepository {
+  constructor(
+    private readonly db: Database,
+    private readonly rendering: MarkdownPipeline = CORE_RENDERING,
+  ) {}
+
+  async postingRules(forumId: number): Promise<ForumPostingTarget | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, type, slug, is_open, allow_threads, allow_replies, allow_polls,
+               allow_attachments, requires_prefix, moderate_new_threads,
+               moderate_new_posts
+          from forums where id = ${forumId}
+      `),
+    ) as Array<{
+      id: number
+      type: 'category' | 'forum' | 'link'
+      slug: string
+      is_open: boolean
+      allow_threads: boolean
+      allow_replies: boolean
+      allow_polls: boolean
+      allow_attachments: boolean
+      requires_prefix: boolean
+      moderate_new_threads: boolean
+      moderate_new_posts: boolean
+    }>
+
+    const row = rows[0]
+    if (!row) return null
+
+    return {
+      id: Number(row.id),
+      type: row.type,
+      slug: row.slug,
+      isOpen: row.is_open,
+      allowThreads: row.allow_threads,
+      allowReplies: row.allow_replies,
+      allowPolls: row.allow_polls,
+      allowAttachments: row.allow_attachments,
+      requiresPrefix: row.requires_prefix,
+      moderateNewThreads: row.moderate_new_threads,
+      moderateNewPosts: row.moderate_new_posts,
+    }
+  }
+
+  async create(record: NewThreadRecord): Promise<CreatedThread> {
+    const vocabulary = await readBoardVocabulary(this.db, this.rendering)
+    const body = await renderThrough(
+      this.rendering,
+      record.message,
+      { source: 'post', viewer: authorRef(record.authorUserId) },
+      vocabularyOptions(vocabulary),
+    )
+
+    return this.db.transaction(async (tx) => {
+      const threadRows = resultRows(
+        await tx.execute(sql`
+          insert into threads
+            (forum_id, title, slug, prefix_id, author_user_id, author_username,
+             visibility, last_post_at, created_at, updated_at)
+          values
+            (${record.forumId}, ${record.title}, ${record.slug}, ${record.prefixId},
+             ${record.authorUserId}, ${record.authorUsername}, ${record.visibility},
+             ${record.createdAt}, ${record.createdAt}, ${record.createdAt})
+          returning id
+        `),
+      ) as Array<{ id: number }>
+      const threadId = Number(threadRows[0]!.id)
+
+      const postRows = resultRows(
+        await tx.execute(sql`
+          insert into posts
+            (thread_id, forum_id, author_user_id, author_username, message,
+             message_html, render_version, vocab_version, body_format, visibility,
+             is_first_post, created_at, search_vector, search_version)
+          values
+            (${threadId}, ${record.forumId}, ${record.authorUserId},
+             ${record.authorUsername}, ${record.message}, ${body.html},
+             ${body.version}, ${vocabulary.revision}, ${BodyFormat.Markdown},
+             ${record.visibility}, true,
+             ${record.createdAt},
+             /*
+              * The **title** is the weight-A field, because this is the
+              * thread's opening post and a thread's subject is its title. The
+              * row cannot be read while it is being inserted, so the value is
+              * passed rather than derived — and it is the same value
+              * indexedSubjectSql would produce for this row (subject null,
+              * is_first_post true), which search-repo.test.ts pins so the
+              * writer and the backfill cannot drift apart.
+              */
+             ${searchVectorSql(sql`${record.title}`, sql`${record.message}`)},
+             ${SEARCH_DOCUMENT_VERSION})
+          returning id
+        `),
+      ) as Array<{ id: number }>
+      const postId = Number(postRows[0]!.id)
+
+      if (record.poll !== undefined) await createPoll(tx as Database, threadId, record.poll)
+
+      if (record.visibility === 'visible') {
+        await applyCreatedContentCounters(tx, {
+          postId,
+          threadId,
+          forumId: record.forumId,
+          authorId: record.authorUserId,
+          authorUsername: record.authorUsername,
+          threadTitle: record.title,
+          createdAt: record.createdAt,
+          isNewThread: true,
+        })
+      } else {
+        await tx.execute(sql`
+          update threads set first_post_id = ${postId} where id = ${threadId}
+        `)
+      }
+
+      if (record.subscribe) {
+        await tx.execute(sql`
+          insert into thread_subscriptions (user_id, thread_id, mode, last_notified_post_id)
+          values (${record.authorUserId}, ${threadId}, 'instant', ${postId})
+          on conflict (user_id, thread_id) do nothing
+        `)
+      }
+
+      return {
+        threadId,
+        postId,
+        slug: record.slug,
+        visibility: record.visibility,
+      }
+    })
+  }
+
+  async replyTarget(threadId: number): Promise<ReplyTarget | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select t.id, t.slug, t.title, t.author_user_id, t.is_locked, t.visibility,
+               t.last_post_id, t.reply_count,
+               f.id as forum_id, f.type as forum_type, f.slug as forum_slug,
+               f.is_open, f.allow_threads, f.allow_replies, f.allow_polls,
+               f.allow_attachments, f.requires_prefix,
+               f.moderate_new_threads, f.moderate_new_posts
+          from threads t
+          join forums f on f.id = t.forum_id
+         where t.id = ${threadId}
+      `),
+    ) as Array<{
+      id: number
+      slug: string
+      title: string
+      author_user_id: number | null
+      is_locked: boolean
+      visibility: 'visible' | 'unapproved' | 'deleted'
+      last_post_id: number | null
+      reply_count: number
+      forum_id: number
+      forum_type: 'category' | 'forum' | 'link'
+      forum_slug: string
+      is_open: boolean
+      allow_threads: boolean
+      allow_replies: boolean
+      allow_polls: boolean
+      allow_attachments: boolean
+      requires_prefix: boolean
+      moderate_new_threads: boolean
+      moderate_new_posts: boolean
+    }>
+
+    const row = rows[0]
+    if (!row) return null
+
+    return {
+      threadId: Number(row.id),
+      slug: row.slug,
+      title: row.title,
+      authorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+      isLocked: row.is_locked,
+      visibility: row.visibility,
+      lastPostId: row.last_post_id === null ? null : Number(row.last_post_id),
+      replyCount: Number(row.reply_count),
+      forum: {
+        id: Number(row.forum_id),
+        type: row.forum_type,
+        slug: row.forum_slug,
+        isOpen: row.is_open,
+        allowThreads: row.allow_threads,
+        allowReplies: row.allow_replies,
+        allowPolls: row.allow_polls,
+        allowAttachments: row.allow_attachments,
+        requiresPrefix: row.requires_prefix,
+        moderateNewThreads: row.moderate_new_threads,
+        moderateNewPosts: row.moderate_new_posts,
+      },
+    }
+  }
+
+  async createReply(record: NewReplyRecord): Promise<{ postId: number }> {
+    const vocabulary = await readBoardVocabulary(this.db, this.rendering)
+    const body = await renderThrough(
+      this.rendering,
+      record.message,
+      { source: 'post', viewer: authorRef(record.authorUserId) },
+      vocabularyOptions(vocabulary),
+    )
+
+    return this.db.transaction(async (tx) => {
+      const postRows = resultRows(
+        await tx.execute(sql`
+          insert into posts
+            (thread_id, forum_id, author_user_id, author_username, message,
+             message_html, render_version, vocab_version, body_format, visibility,
+             is_first_post, created_at, search_vector, search_version)
+          values
+            (${record.threadId}, ${record.forumId}, ${record.authorUserId},
+             ${record.authorUsername}, ${record.message}, ${body.html},
+             ${body.version}, ${vocabulary.revision}, ${BodyFormat.Markdown},
+             ${record.visibility}, false,
+             ${record.createdAt},
+             /*
+              * No weight-A field, and that is the rule rather than an
+              * omission: a reply has no subject of its own, and folding the
+              * thread's title in here would make one title term match every
+              * post in the thread — forty hits that are all the same thread,
+              * where the opening post already stands for it.
+              */
+             ${searchVectorSql(sql`${null}`, sql`${record.message}`)},
+             ${SEARCH_DOCUMENT_VERSION})
+          returning id
+        `),
+      ) as Array<{ id: number }>
+      const postId = Number(postRows[0]!.id)
+
+      if (record.visibility === 'visible') {
+        await applyCreatedContentCounters(tx, {
+          postId,
+          threadId: record.threadId,
+          forumId: record.forumId,
+          authorId: record.authorUserId,
+          authorUsername: record.authorUsername,
+          threadTitle: record.threadTitle,
+          createdAt: record.createdAt,
+          isNewThread: false,
+        })
+      }
+
+      if (record.subscribe) {
+        await tx.execute(sql`
+          insert into thread_subscriptions (user_id, thread_id, mode, last_notified_post_id)
+          values (${record.authorUserId}, ${record.threadId}, 'instant', ${postId})
+          on conflict (user_id, thread_id) do nothing
+        `)
+      }
+
+      return { postId }
+    })
+  }
+
+  async lastPostAt(userId: number): Promise<Date | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select created_at from posts
+         where author_user_id = ${userId} and visibility <> 'deleted'
+         order by created_at desc
+         limit 1
+      `),
+    ) as Array<{ created_at: Date }>
+
+    const at = rows[0]?.created_at
+    return at === undefined ? null : new Date(at)
+  }
+
+  async allowedPrefixIds(forumId: number): Promise<readonly number[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select p.id
+          from thread_prefixes p
+          left join forums f on f.id = ${forumId}
+         where p.forum_path_prefix is null
+            or f.path = p.forum_path_prefix
+            or f.path like p.forum_path_prefix || '.%'
+         order by p.display_order, p.id
+      `),
+    ) as Array<{ id: number }>
+
+    return rows.map((row) => Number(row.id))
+  }
+
+  async listPrefixes(
+    forumId: number,
+  ): Promise<readonly { id: number; label: string; token: string | null }[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select p.id, p.label, p.token
+          from thread_prefixes p
+          left join forums f on f.id = ${forumId}
+         where p.forum_path_prefix is null
+            or f.path = p.forum_path_prefix
+            or f.path like p.forum_path_prefix || '.%'
+         order by p.display_order, p.id
+      `),
+    ) as Array<{ id: number; label: string; token: string | null }>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      label: row.label,
+      token: row.token,
+    }))
+  }
+}
+
+async function createPoll(tx: Database, threadId: number, poll: ValidatedPoll): Promise<void> {
+  const rows = resultRows(
+    await tx.execute(sql`
+      insert into polls (thread_id, question, closes_at, max_options, allow_revote, public_votes)
+      values (${threadId}, ${poll.question}, ${poll.closesAt}, ${poll.maxOptions},
+              ${poll.allowRevote}, ${poll.publicVotes}) returning id
+    `),
+  ) as Array<{ id: number }>
+  const pollId = rows[0]?.id
+  if (pollId === undefined) throw new Error('Poll insert returned no row.')
+  await tx.execute(sql`
+    insert into poll_options (poll_id, label, display_order)
+    values ${sql.join(
+      poll.options.map((label, index) => sql`(${pollId}, ${label}, ${index})`),
+      sql`, `,
+    )}
+  `)
+}