@meith/db 0.16.0

package/src/post-repo.ts

@@ -0,0 +1,261 @@
+import { and, asc, eq, gt, type SQL, sql } from 'drizzle-orm'
+import { alias } from 'drizzle-orm/pg-core'
+
+import { type ContentScope, PUBLIC_CONTENT } from '@meith/core'
+import { sourceAsMarkdown } from '@meith/markdown'
+import type {
+  PostListingRow,
+  PostLocation,
+  PostPage,
+  PostRepository,
+  PostRevision,
+  QuotablePost,
+} from '@meith/posts'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { posts, users } from './schema'
+import { visibleIn } from './visibility'
+
+const editors = alias(users, 'editors')
+
+function toPost(row: {
+  id: number
+  threadId: number
+  forumId: number
+  beforeCount: number
+  authorUserId: number | null
+  authorUsername: string
+  authorPostCount: number | null
+  authorJoinedAt: Date | null
+  message: string
+  messageHtml: string | null
+  renderVersion: number
+  bodyFormat: number
+  isFirstPost: boolean
+  visibility: string
+  createdAt: Date
+  editedAt: Date | null
+  editedByUsername: string | null
+  editReason: string | null
+}): PostListingRow {
+  return {
+    id: row.id,
+    threadId: row.threadId,
+    forumId: row.forumId,
+    number: Number(row.beforeCount) + 1,
+    authorUserId: row.authorUserId,
+    authorUsername: row.authorUsername,
+    authorPostCount: row.authorPostCount ?? 0,
+    authorJoinedAt: row.authorJoinedAt,
+    message: row.message,
+    messageHtml: row.messageHtml,
+    renderVersion: Number(row.renderVersion),
+    bodyFormat: Number(row.bodyFormat),
+    isFirstPost: row.isFirstPost,
+    visibility: row.visibility as PostListingRow['visibility'],
+    createdAt: row.createdAt,
+    editedAt: row.editedAt,
+    editedByUsername: row.editedByUsername,
+    editReason: row.editReason,
+  }
+}
+
+export class PostgresPostRepository implements PostRepository {
+  constructor(private readonly db: Database) {}
+
+  async findRatingTarget(postId: number) {
+    const rows = await this.db
+      .select({ id: posts.id, threadId: posts.threadId, authorUserId: posts.authorUserId })
+      .from(posts)
+      .where(eq(posts.id, postId))
+      .limit(1)
+    return rows[0] ?? null
+  }
+
+  async findQuotable(threadId: number, postId: number): Promise<QuotablePost | null> {
+    const rows = await this.db
+      .select({
+        id: posts.id,
+        authorUsername: posts.authorUsername,
+        message: posts.message,
+        bodyFormat: posts.bodyFormat,
+      })
+      .from(posts)
+      .where(
+        and(
+          eq(posts.id, postId),
+          eq(posts.threadId, threadId),
+          visibleIn(posts.visibility, PUBLIC_CONTENT),
+        ),
+      )
+      .limit(1)
+
+    const row = rows[0]
+    if (row === undefined) return null
+    return {
+      id: row.id,
+      authorUsername: row.authorUsername,
+      message: sourceAsMarkdown(row.message, Number(row.bodyFormat)),
+    }
+  }
+
+  async listRevisions(threadId: number, postId: number): Promise<readonly PostRevision[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select r.revision, r.message, r.subject, r.edited_by_user_id,
+               coalesce(u.username, 'Deleted member') as edited_by_username,
+               r.edit_reason, r.created_at, false as current
+          from post_revisions r
+          left join users u on u.id = r.edited_by_user_id
+         where r.post_id = ${postId}
+           and exists (select 1 from posts p where p.id = r.post_id and p.thread_id = ${threadId})
+        union all
+        select p.revision_count, p.message, p.subject, p.edited_by_user_id,
+               coalesce(u.username, p.author_username, 'Deleted member'),
+               p.edit_reason, coalesce(p.edited_at, p.created_at), true
+          from posts p
+          left join users u on u.id = p.edited_by_user_id
+         where p.id = ${postId} and p.thread_id = ${threadId}
+        order by revision asc
+      `),
+    ) as Array<{
+      revision: number
+      message: string
+      subject: string | null
+      edited_by_user_id: number | null
+      edited_by_username: string
+      edit_reason: string | null
+      created_at: Date | string
+      current: boolean
+    }>
+
+    return rows.map((row) => ({
+      revision: Number(row.revision),
+      message: row.message,
+      subject: row.subject,
+      editedByUserId: row.edited_by_user_id === null ? null : Number(row.edited_by_user_id),
+      editedByUsername: row.edited_by_username,
+      reason: row.edit_reason,
+      createdAt: new Date(row.created_at),
+      current: row.current,
+    }))
+  }
+
+  async locate(
+    threadId: number,
+    postId: number,
+    options: { readonly scope: ContentScope; readonly pageSize: number },
+  ): Promise<PostLocation | null> {
+    const visible: SQL = visibleIn(posts.visibility, options.scope)
+    const size = Math.max(1, Math.trunc(options.pageSize))
+
+    const counted = await this.db
+      .select({
+        number: sql<number>`count(*) filter (where ${posts.id} <= ${postId})::int`,
+        found: sql<number>`count(*) filter (where ${posts.id} = ${postId})::int`,
+      })
+      .from(posts)
+      .where(and(eq(posts.threadId, threadId), visible))
+
+    const row = counted[0]
+    if (row === undefined || Number(row.found) === 0) return null
+
+    const number = Number(row.number)
+    const page = Math.floor((number - 1) / size) + 1
+    if (page === 1) return { number, page, afterId: null }
+
+    const cursor = await this.db
+      .select({ id: posts.id })
+      .from(posts)
+      .where(and(eq(posts.threadId, threadId), visible))
+      .orderBy(asc(posts.id))
+      .limit(1)
+      .offset((page - 1) * size - 1)
+
+    return { number, page, afterId: cursor[0]?.id ?? null }
+  }
+
+  async findVisibleById(threadId: number, postId: number): Promise<number | null> {
+    const rows = await this.db
+      .select({ id: posts.id })
+      .from(posts)
+      .where(
+        and(
+          eq(posts.threadId, threadId),
+          eq(posts.id, postId),
+          visibleIn(posts.visibility, PUBLIC_CONTENT),
+        ),
+      )
+      .limit(1)
+    return rows[0]?.id ?? null
+  }
+
+  async listThread(
+    threadId: number,
+    options: {
+      readonly afterId?: number
+      readonly offset?: number
+      readonly limit: number
+      readonly scope: ContentScope
+    },
+  ): Promise<PostPage> {
+    const visible: SQL = visibleIn(posts.visibility, options.scope)
+
+    const beforeCount = options.afterId
+      ? sql<number>`(
+          select count(*)::int from ${posts}
+          where ${posts.threadId} = ${threadId}
+            and ${visible}
+            and ${posts.id} <= ${options.afterId}
+        )`
+      : sql<number>`0`
+
+    const rows = await this.db
+      .select({
+        id: posts.id,
+        threadId: posts.threadId,
+        forumId: posts.forumId,
+        beforeCount,
+        authorUserId: posts.authorUserId,
+        authorUsername: posts.authorUsername,
+        authorPostCount: users.postCount,
+        authorJoinedAt: users.createdAt,
+        message: posts.message,
+        messageHtml: posts.messageHtml,
+        renderVersion: posts.renderVersion,
+        bodyFormat: posts.bodyFormat,
+        isFirstPost: posts.isFirstPost,
+        visibility: posts.visibility,
+        createdAt: posts.createdAt,
+        editedAt: posts.editedAt,
+        editedByUsername: editors.username,
+        editReason: posts.editReason,
+      })
+      .from(posts)
+      .leftJoin(users, eq(posts.authorUserId, users.id))
+      .leftJoin(editors, eq(posts.editedByUserId, editors.id))
+      .where(
+        and(
+          eq(posts.threadId, threadId),
+          visible,
+          ...(options.afterId ? [gt(posts.id, options.afterId)] : []),
+        ),
+      )
+      .orderBy(asc(posts.id))
+      .limit(options.limit + 1)
+      .offset(options.offset ?? 0)
+
+    const skipped = options.offset ?? 0
+    const page = rows
+      .slice(0, options.limit)
+      .map((row, index) =>
+        toPost({ ...row, beforeCount: Number(row.beforeCount) + skipped + index }),
+      )
+    const last = page.at(-1)
+    return {
+      rows: page,
+      nextAfterId: rows.length > options.limit && last ? last.id : null,
+    }
+  }
+}

package/src/post-writes.ts

@@ -0,0 +1,227 @@
+import { sql } from 'drizzle-orm'
+
+import {
+  authorRef,
+  BodyFormat,
+  CORE_RENDERING,
+  type MarkdownPipeline,
+  renderThrough,
+  vocabularyOptions,
+} from '@meith/markdown'
+import type {
+  PostEditRecord,
+  PostEditTarget,
+  PostVisibilityRecord,
+  PostWriteRepository,
+} from '@meith/posts'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { indexedSubjectSql, SEARCH_DOCUMENT_VERSION, searchVectorSql } from './search-repo'
+import { logModeratorAction } from './thread-counters'
+import { applyVisibilityChangeCounters } from './visibility-counters'
+import { readBoardVocabulary } from './vocabulary-repo'
+
+function isCounted(visibility: string): boolean {
+  return visibility === 'visible'
+}
+
+function actedOnAnother(actorUserId: number, authorUserId: number | null): boolean {
+  return authorUserId === null || actorUserId !== authorUserId
+}
+
+function scopedDetail(record: {
+  readonly postId: number
+  readonly threadId: number
+  readonly forumId: number
+}): Record<string, unknown> {
+  return {
+    postId: record.postId,
+    threadId: record.threadId,
+    forumId: record.forumId,
+    forumIds: [record.forumId],
+  }
+}
+
+export class PostgresPostWriteRepository implements PostWriteRepository {
+  constructor(
+    private readonly db: Database,
+    private readonly rendering: MarkdownPipeline = CORE_RENDERING,
+  ) {}
+
+  async findEditTarget(threadId: number, postId: number): Promise<PostEditTarget | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select p.id, p.thread_id, p.forum_id, p.author_user_id, p.subject, p.message,
+               p.visibility, p.is_first_post, p.revision_count, p.created_at,
+               t.slug as thread_slug, t.title as thread_title, t.is_locked,
+               t.visibility as thread_visibility,
+               f.slug as forum_slug, f.is_open
+          from posts p
+          join threads t on t.id = p.thread_id
+          join forums f on f.id = p.forum_id
+         where p.id = ${postId} and p.thread_id = ${threadId}
+      `),
+    ) as Array<{
+      id: number
+      thread_id: number
+      forum_id: number
+      author_user_id: number | null
+      subject: string | null
+      message: string
+      visibility: 'visible' | 'unapproved' | 'deleted'
+      is_first_post: boolean
+      revision_count: number
+      created_at: Date
+      thread_slug: string
+      thread_title: string
+      is_locked: boolean
+      thread_visibility: 'visible' | 'unapproved' | 'deleted'
+      forum_slug: string
+      is_open: boolean
+    }>
+
+    const row = rows[0]
+    if (!row) return null
+
+    return {
+      post: {
+        id: Number(row.id),
+        threadId: Number(row.thread_id),
+        forumId: Number(row.forum_id),
+        authorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+        subject: row.subject,
+        message: row.message,
+        visibility: row.visibility,
+        isFirstPost: row.is_first_post,
+        revisionCount: Number(row.revision_count),
+        createdAt: new Date(row.created_at),
+      },
+      thread: {
+        id: Number(row.thread_id),
+        slug: row.thread_slug,
+        title: row.thread_title,
+        isLocked: row.is_locked,
+        visibility: row.thread_visibility,
+      },
+      forum: { id: Number(row.forum_id), slug: row.forum_slug, isOpen: row.is_open },
+    }
+  }
+
+  async applyEdit(record: PostEditRecord): Promise<void> {
+    const vocabulary = await readBoardVocabulary(this.db, this.rendering)
+    const body = await renderThrough(
+      this.rendering,
+      record.message,
+      { source: 'post', viewer: authorRef(record.editedByUserId), postId: record.postId },
+      vocabularyOptions(vocabulary),
+    )
+
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`
+        insert into post_revisions
+          (post_id, revision, message, subject, edited_by_user_id, edit_reason, created_at)
+        values
+          (${record.postId}, ${record.revision}, ${record.previousMessage},
+           ${record.previousSubject}, ${record.editedByUserId}, ${record.reason},
+           ${record.editedAt})
+      `)
+
+      const notice = record.silent
+        ? sql``
+        : sql`edited_at = ${record.editedAt},
+              edited_by_user_id = ${record.editedByUserId},
+              edit_reason = ${record.reason},`
+      await tx.execute(sql`
+        update posts p
+           set message = ${record.message},
+               message_html = ${body.html},
+               /*
+                * The indexed document is rewritten with the text, in the
+                * same statement. An edit that changed the body and left the
+                * vector alone would make the post findable by words it no
+                * longer contains — and unfindable by the ones it does.
+                *
+                * Through indexedSubjectSql rather than off subject, which is
+                * null for everything this board writes: reading the column
+                * alone left the weight-A half of the document empty, so an
+                * edited opening post lost the title an edit is supposed to
+                * preserve. The alias is why the statement names "posts p".
+                */
+               search_vector = ${searchVectorSql(indexedSubjectSql(sql`p`), sql`${record.message}`)},
+               search_version = ${SEARCH_DOCUMENT_VERSION},
+               render_version = ${body.version},
+               vocab_version = ${vocabulary.revision},
+               /*
+                * Named rather than left to the column default: an edit is the
+                * one path that can turn a legacy row into a current one, and a
+                * row whose text is now Markdown while its stamp still says
+                * BBCode would be converted a second time by the backfill.
+                */
+               body_format = ${BodyFormat.Markdown},
+               visibility = ${record.toVisibility},
+               ${notice}
+               revision_count = revision_count + 1
+         where id = ${record.postId}
+      `)
+
+      const delta =
+        (isCounted(record.toVisibility) ? 1 : 0) - (isCounted(record.fromVisibility) ? 1 : 0)
+      if (delta !== 0) {
+        await applyVisibilityChangeCounters(tx, {
+          postId: record.postId,
+          threadId: record.threadId,
+          forumId: record.forumId,
+          authorId: record.authorUserId,
+          isFirstPost: record.isFirstPost,
+          delta: delta as 1 | -1,
+        })
+      }
+
+      if (actedOnAnother(record.editedByUserId, record.authorUserId)) {
+        await logModeratorAction(
+          tx,
+          'post.edit',
+          record.editedByUserId,
+          scopedDetail(record),
+          record.editedAt,
+        )
+      }
+    })
+  }
+
+  async applyVisibility(record: PostVisibilityRecord): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const moved = await tx.execute(sql`
+        update posts set visibility = ${record.to}
+         where id = ${record.postId} and visibility = ${record.from}
+         returning id
+      `)
+      if (resultRows(moved).length === 0) return false
+
+      const delta = (isCounted(record.to) ? 1 : 0) - (isCounted(record.from) ? 1 : 0)
+      if (delta !== 0) {
+        await applyVisibilityChangeCounters(tx, {
+          postId: record.postId,
+          threadId: record.threadId,
+          forumId: record.forumId,
+          authorId: record.authorUserId,
+          isFirstPost: record.isFirstPost,
+          delta: delta as 1 | -1,
+        })
+      }
+
+      if (actedOnAnother(record.actedByUserId, record.authorUserId)) {
+        await logModeratorAction(
+          tx,
+          record.to === 'deleted' ? 'post.delete' : 'post.restore',
+          record.actedByUserId,
+          scopedDetail(record),
+          record.at,
+        )
+      }
+
+      return true
+    })
+  }
+}

package/src/presence-repo.ts

@@ -0,0 +1,220 @@
+import { sql } from 'drizzle-orm'
+
+import type { ContentScope } from '@meith/core'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+import { inAudience } from './thread-audience'
+import { visibleIn } from './visibility'
+
+export const ONLINE_WINDOW_MINUTES = 15
+
+export interface OnlineScope {
+  readonly forumIds: readonly number[]
+  readonly ownThreadsOnlyForumIds: readonly number[]
+  readonly viewerUserId: number | null
+  readonly content: ContentScope
+  readonly seesInvisible: boolean
+}
+
+export interface OnlineMember {
+  readonly userId: number
+  readonly username: string
+  readonly invisible: boolean
+  readonly lastSeenAt: Date
+  readonly forumId: number | null
+  readonly forumTitle: string | null
+  readonly threadId: number | null
+  readonly threadTitle: string | null
+  readonly threadSlug: string | null
+}
+
+export interface OnlineSnapshot {
+  readonly members: readonly OnlineMember[]
+  readonly guestCount: number
+  readonly total: number
+  readonly invisibleCount: number
+}
+
+export interface OnlineRecord {
+  readonly count: number
+  readonly at: Date | null
+}
+
+export class PostgresPresenceRepository {
+  constructor(private readonly db: Database) {}
+
+  async onlineNow(now: Date, scope: OnlineScope): Promise<OnlineSnapshot> {
+    const since = new Date(now.getTime() - ONLINE_WINDOW_MINUTES * 60_000)
+
+    const mayName =
+      scope.forumIds.length === 0
+        ? sql`false`
+        : sql`s.location_forum_id in (${sql.join(
+            scope.forumIds.map((id) => sql`${id}`),
+            sql`, `,
+          )})`
+
+    const mayNameThread = sql`(${inAudience(
+      sql`t.forum_id`,
+      sql`t.author_user_id`,
+      scope,
+    )} and ${visibleIn(sql`t.visibility`, scope.content)})`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select distinct on (coalesce(s.user_id, -s.id))
+               s.user_id, s.id as session_id, s.last_seen_at,
+               u.username, u.invisible,
+               case when ${mayName} then s.location_forum_id end as forum_id,
+               case when ${mayName} then f.title end as forum_title,
+               case when ${mayNameThread} then s.location_thread_id end as thread_id,
+               case when ${mayNameThread} then t.title end as thread_title,
+               case when ${mayNameThread} then t.slug end as thread_slug
+          from sessions s
+          left join users u on u.id = s.user_id
+          left join forums f on f.id = s.location_forum_id
+          left join threads t on t.id = s.location_thread_id
+         where s.revoked_at is null
+           and s.last_seen_at >= ${since}
+           and (s.user_id is null or u.state = 'active')
+         order by coalesce(s.user_id, -s.id), s.last_seen_at desc
+      `),
+    ) as Array<Record<string, unknown>>
+
+    let guestCount = 0
+    let invisibleCount = 0
+    const members: OnlineMember[] = []
+
+    for (const row of rows) {
+      if (row.user_id === null) {
+        guestCount += 1
+        continue
+      }
+
+      const invisible = row.invisible === true
+      if (invisible) invisibleCount += 1
+      if (invisible && !scope.seesInvisible) continue
+
+      members.push({
+        userId: Number(row.user_id),
+        username: String(row.username),
+        invisible,
+        lastSeenAt: toDate(row.last_seen_at),
+        forumId: row.forum_id === null ? null : Number(row.forum_id),
+        forumTitle: row.forum_title === null ? null : String(row.forum_title),
+        threadId: row.thread_id === null ? null : Number(row.thread_id),
+        threadTitle: row.thread_title === null ? null : String(row.thread_title),
+        threadSlug: row.thread_slug === null ? null : String(row.thread_slug),
+      })
+    }
+
+    return {
+      members,
+      guestCount,
+      total: guestCount + members.length,
+      invisibleCount: scope.seesInvisible ? invisibleCount : 0,
+    }
+  }
+
+  /**
+   * Records that an anonymous reader is here, under a session row with no user.
+   *
+   * The read side has counted these rows since presence was written — the
+   * `user_id` column is nullable for exactly this — but nothing ever wrote one,
+   * so every board reported zero guests forever. This is the missing half.
+   *
+   * `windowSeconds` throttles the write the way the member path does: a reader
+   * clicking through a thread should cost one update a minute, not one an
+   * article. The insert is unconditional, though, or a reader whose first page
+   * view landed inside another reader's throttle window would never appear.
+   */
+  async touchGuest(input: {
+    readonly tokenHash: string
+    readonly location: {
+      readonly path: string
+      readonly forumId: number | null
+      readonly threadId: number | null
+    }
+    readonly now: Date
+    readonly windowSeconds: number
+    readonly expiresAt: Date
+  }): Promise<void> {
+    const cutoff = new Date(input.now.getTime() - input.windowSeconds * 1000)
+
+    await this.db.execute(sql`
+      insert into sessions
+        (token_hash, user_id, location_path, location_forum_id, location_thread_id,
+         last_seen_at, expires_at)
+      values
+        (${input.tokenHash}, null, ${input.location.path}, ${input.location.forumId},
+         ${input.location.threadId}, ${input.now}, ${input.expiresAt})
+      on conflict (token_hash) do update
+         set location_path      = excluded.location_path,
+             location_forum_id  = excluded.location_forum_id,
+             location_thread_id = excluded.location_thread_id,
+             last_seen_at       = excluded.last_seen_at,
+             expires_at         = excluded.expires_at
+       where sessions.user_id is null
+         and sessions.last_seen_at < ${cutoff}
+    `)
+  }
+
+  /**
+   * Forgets a guest row, for when the reader holding it has just signed in.
+   *
+   * Without this they are two people for the next fifteen minutes — a member in
+   * the list and a guest in the count — because the row they browsed under is
+   * still inside the window and there is nothing tying it to the account they
+   * have now proved they own.
+   */
+  async dropGuest(tokenHash: string): Promise<void> {
+    await this.db.execute(sql`
+      delete from sessions where token_hash = ${tokenHash} and user_id is null
+    `)
+  }
+
+  async concurrentCount(now: Date): Promise<number> {
+    const since = new Date(now.getTime() - ONLINE_WINDOW_MINUTES * 60_000)
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(distinct coalesce(s.user_id, -s.id))::int as n
+          from sessions s
+         where s.revoked_at is null and s.last_seen_at >= ${since}
+      `),
+    ) as Array<{ n: number }>
+
+    return rows[0]?.n ?? 0
+  }
+
+  async recordIfHigher(count: number, now: Date): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update board_stats
+           set most_online_count = ${count},
+               most_online_at = ${now},
+               updated_at = ${now}
+         where id = 1 and most_online_count < ${count}
+        returning most_online_count
+      `),
+    ) as Array<unknown>
+
+    return rows.length > 0
+  }
+
+  async readRecord(): Promise<OnlineRecord> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select most_online_count, most_online_at from board_stats where id = 1
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    if (row === undefined) return { count: 0, at: null }
+    return {
+      count: Number(row.most_online_count),
+      at: row.most_online_at === null ? null : toDate(row.most_online_at),
+    }
+  }
+}