@meith/db 0.16.0

package/src/client.ts

@@ -0,0 +1,85 @@
+import { drizzle, type PostgresJsDatabase } from 'drizzle-orm/postgres-js'
+import postgres from 'postgres'
+
+import { ConfigurationError, env } from '@meith/core'
+
+import * as schema from './schema'
+
+export type Database = PostgresJsDatabase<typeof schema>
+
+interface DbGlobal {
+  __forumSql: ReturnType<typeof postgres> | undefined
+  __forumDb: Database | undefined
+}
+
+const globalRef = globalThis as unknown as DbGlobal
+
+function connectionOptions() {
+  return {
+    max: env.DATABASE_POOL_MAX,
+    prepare: false,
+    idle_timeout: 20,
+    max_lifetime: 60 * 30,
+    connect_timeout: 10,
+    onnotice: () => {},
+  } as const
+}
+
+export function getDb(): Database {
+  if (env.DATA_SOURCE !== 'postgres') {
+    throw new ConfigurationError(
+      'getDb() called while DATA_SOURCE is "' +
+        env.DATA_SOURCE +
+        '". A repository is talking to Postgres directly instead of going ' +
+        'through its driver. Fix the call site, do not set DATABASE_URL.',
+    )
+  }
+
+  if (globalRef.__forumDb) return globalRef.__forumDb
+
+  const url = env.DATABASE_URL
+  if (!url) {
+    throw new ConfigurationError('DATABASE_URL is required when DATA_SOURCE is "postgres".')
+  }
+
+  const sql = postgres(url, connectionOptions())
+  const db = drizzle(sql, { schema, casing: 'snake_case' })
+  restoreDateSerialisers(sql)
+
+  globalRef.__forumSql = sql
+  globalRef.__forumDb = db
+
+  return db
+}
+
+const DATE_OIDS = ['1184', '1114', '1082', '1083', '1182', '1185', '1115', '1231'] as const
+
+function restoreDateSerialisers(client: ReturnType<typeof postgres>): void {
+  const serialisers = (
+    client as unknown as { options: { serializers: Record<string, (v: unknown) => unknown> } }
+  ).options.serializers
+  for (const oid of DATE_OIDS) {
+    serialisers[oid] = (value: unknown) => (value instanceof Date ? value.toISOString() : value)
+  }
+}
+
+export function createIsolatedDb(url: string, poolMax = 1) {
+  const sql = postgres(url, { ...connectionOptions(), max: poolMax })
+  const db = drizzle(sql, { schema, casing: 'snake_case' })
+  restoreDateSerialisers(sql)
+  return {
+    db,
+    sql,
+    close: () => sql.end({ timeout: 5 }),
+  }
+}
+
+export async function closeDb(): Promise<void> {
+  const sql = globalRef.__forumSql
+  if (!sql) return
+  await sql.end({ timeout: 5 })
+  globalRef.__forumSql = undefined
+  globalRef.__forumDb = undefined
+}
+
+export { schema }

package/src/content-admin-repo.ts

@@ -0,0 +1,298 @@
+import { sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+import type { WordFilterRule } from '@meith/markdown'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export interface WordFilterRow extends WordFilterRule {
+  readonly id: number
+  readonly enabled: boolean
+}
+
+export interface SmileyRow {
+  readonly id: number
+  readonly code: string
+  readonly src: string
+  readonly alt: string | null
+  readonly enabled: boolean
+}
+
+export interface DirectiveRow {
+  readonly id: number
+  readonly name: string
+  readonly block: boolean
+  readonly description: string | null
+  readonly enabled: boolean
+}
+
+export interface ThreadPrefixRow {
+  readonly id: number
+  readonly label: string
+  readonly token: string | null
+  readonly displayOrder: number
+  readonly forumPathPrefix: string | null
+}
+
+export class PostgresContentAdminRepository {
+  constructor(private readonly db: Database) {}
+
+  async listWordFilters(): Promise<readonly WordFilterRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, pattern, replacement, whole_word, enabled
+          from word_filters order by id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map(toWordFilter)
+  }
+
+  async activeWordFilters(): Promise<readonly WordFilterRule[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select pattern, replacement, whole_word from word_filters
+         where enabled = true and pattern <> ''
+         order by id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      pattern: String(row.pattern),
+      replacement: String(row.replacement),
+      wholeWord: row.whole_word === true,
+    }))
+  }
+
+  async createWordFilter(input: WordFilterRule): Promise<number> {
+    const pattern = input.pattern.trim()
+    if (pattern === '') throw new ValidationError(msg('error.db.filter-needs-something-match'))
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into word_filters (pattern, replacement, whole_word)
+        values (${pattern}, ${input.replacement}, ${input.wholeWord})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    return Number(rows[0]?.id)
+  }
+
+  async updateWordFilter(
+    id: number,
+    input: WordFilterRule & { readonly enabled: boolean },
+  ): Promise<void> {
+    const pattern = input.pattern.trim()
+    if (pattern === '') throw new ValidationError(msg('error.db.filter-needs-something-match'))
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update word_filters
+           set pattern = ${pattern}, replacement = ${input.replacement},
+               whole_word = ${input.wholeWord}, enabled = ${input.enabled}
+         where id = ${id}
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-filter'))
+  }
+
+  async deleteWordFilter(id: number): Promise<void> {
+    await this.db.execute(sql`delete from word_filters where id = ${id}`)
+  }
+
+  async listPrefixes(): Promise<readonly ThreadPrefixRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, label, token, display_order, forum_path_prefix
+          from thread_prefixes order by display_order, id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      label: String(row.label),
+      token: row.token === null ? null : String(row.token),
+      displayOrder: Number(row.display_order),
+      forumPathPrefix: row.forum_path_prefix === null ? null : String(row.forum_path_prefix),
+    }))
+  }
+
+  async createPrefix(input: {
+    readonly label: string
+    readonly token: string | null
+    readonly displayOrder: number
+    readonly forumPathPrefix: string | null
+  }): Promise<number> {
+    if (input.label.trim() === '') throw new ValidationError(msg('error.db.prefix-needs-label'))
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into thread_prefixes (label, token, display_order, forum_path_prefix)
+        values (${input.label.trim()}, ${input.token}, ${input.displayOrder},
+                ${input.forumPathPrefix})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    return Number(rows[0]?.id)
+  }
+
+  async deletePrefix(id: number): Promise<void> {
+    await this.db.execute(sql`delete from thread_prefixes where id = ${id}`)
+  }
+
+  async vocabularyRevision(): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select version from cache_versions where key = 'markdown_vocabulary'
+      `),
+    ) as Array<{ version: number }>
+
+    return Number(rows[0]?.version ?? 0)
+  }
+
+  async bumpVocabulary(): Promise<void> {
+    await this.db.execute(sql`
+      insert into cache_versions (key, version) values ('markdown_vocabulary', 1)
+      on conflict (key) do update
+         set version = cache_versions.version + 1, bumped_at = now()
+    `)
+  }
+
+  async listSmilies(): Promise<readonly SmileyRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, code, src, alt, enabled from smilies order by code
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      code: String(row.code),
+      src: String(row.src),
+      alt: row.alt === null ? null : String(row.alt),
+      enabled: row.enabled === true,
+    }))
+  }
+
+  async createSmiley(input: {
+    readonly code: string
+    readonly src: string
+    readonly alt: string | null
+  }): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into smilies (code, src, alt)
+        values (${input.code}, ${input.src}, ${input.alt})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    await this.bumpVocabulary()
+    return Number(rows[0]?.id)
+  }
+
+  async updateSmiley(
+    id: number,
+    input: {
+      readonly code: string
+      readonly src: string
+      readonly alt: string | null
+      readonly enabled: boolean
+    },
+  ): Promise<void> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update smilies
+           set code = ${input.code}, src = ${input.src}, alt = ${input.alt},
+               enabled = ${input.enabled}
+         where id = ${id}
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-smiley'))
+    await this.bumpVocabulary()
+  }
+
+  async deleteSmiley(id: number): Promise<void> {
+    await this.db.execute(sql`delete from smilies where id = ${id}`)
+    await this.bumpVocabulary()
+  }
+
+  async listDirectives(): Promise<readonly DirectiveRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, name, block, description, enabled from custom_directives order by name
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      name: String(row.name),
+      block: row.block === true,
+      description: row.description === null ? null : String(row.description),
+      enabled: row.enabled === true,
+    }))
+  }
+
+  async createDirective(input: {
+    readonly name: string
+    readonly block: boolean
+    readonly description: string | null
+  }): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into custom_directives (name, block, description)
+        values (${input.name}, ${input.block}, ${input.description})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    await this.bumpVocabulary()
+    return Number(rows[0]?.id)
+  }
+
+  async updateDirective(
+    id: number,
+    input: {
+      readonly name: string
+      readonly block: boolean
+      readonly description: string | null
+      readonly enabled: boolean
+    },
+  ): Promise<void> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update custom_directives
+           set name = ${input.name}, block = ${input.block},
+               description = ${input.description}, enabled = ${input.enabled}
+         where id = ${id}
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-directive'))
+    await this.bumpVocabulary()
+  }
+
+  async deleteDirective(id: number): Promise<void> {
+    await this.db.execute(sql`delete from custom_directives where id = ${id}`)
+    await this.bumpVocabulary()
+  }
+}
+
+function toWordFilter(row: Record<string, unknown>): WordFilterRow {
+  return {
+    id: Number(row.id),
+    pattern: String(row.pattern),
+    replacement: String(row.replacement),
+    wholeWord: row.whole_word === true,
+    enabled: row.enabled === true,
+  }
+}

package/src/content-counters.ts

@@ -0,0 +1,152 @@
+import type { SQLWrapper } from 'drizzle-orm'
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { applyAncestorVisibilityChange } from './visibility-counters'
+
+export interface CreatedContent {
+  readonly postId: number
+  readonly threadId: number
+  readonly forumId: number
+  readonly authorId: number | null
+  readonly authorUsername: string
+  readonly threadTitle: string
+  readonly createdAt: Date
+  readonly isNewThread: boolean
+}
+
+interface CounterTransaction {
+  execute(query: SQLWrapper): Promise<unknown>
+}
+
+export async function applyCreatedContentCounters(
+  tx: CounterTransaction,
+  content: CreatedContent,
+): Promise<void> {
+  const newer = sql`last_post_at is null or last_post_id is null
+    or last_post_at < ${content.createdAt}
+    or (last_post_at = ${content.createdAt} and last_post_id < ${content.postId})`
+  const threadNewer = content.isNewThread ? sql`true` : newer
+
+  await tx.execute(sql`
+    update forums
+       set post_count = post_count + 1,
+           thread_count = thread_count + ${content.isNewThread ? 1 : 0},
+           last_post_id = case when ${newer} then ${content.postId} else last_post_id end,
+           last_post_thread_id = case when ${newer} then ${content.threadId} else last_post_thread_id end,
+           last_post_thread_title = case when ${newer} then ${content.threadTitle} else last_post_thread_title end,
+           last_post_user_id = case when ${newer} then ${content.authorId} else last_post_user_id end,
+           last_post_username = case when ${newer} then ${content.authorUsername} else last_post_username end,
+           last_post_at = case when ${newer} then ${content.createdAt} else last_post_at end,
+           updated_at = now()
+     where id = ${content.forumId}
+  `)
+
+  await tx.execute(sql`
+    update threads
+       set first_post_id = case when ${content.isNewThread} then ${content.postId} else first_post_id end,
+           reply_count = reply_count + ${content.isNewThread ? 0 : 1},
+           last_post_id = case when ${threadNewer} then ${content.postId} else last_post_id end,
+           last_post_user_id = case when ${threadNewer} then ${content.authorId} else last_post_user_id end,
+           last_post_username = case when ${threadNewer} then ${content.authorUsername} else last_post_username end,
+           last_post_at = case when ${threadNewer} then ${content.createdAt} else last_post_at end,
+           updated_at = now()
+     where id = ${content.threadId}
+  `)
+
+  if (content.authorId !== null) {
+    await tx.execute(sql`
+      update users
+         set post_count = post_count + 1,
+             thread_count = thread_count + ${content.isNewThread ? 1 : 0},
+             updated_at = now()
+       where id = ${content.authorId}
+    `)
+  }
+
+  await tx.execute(sql`
+    insert into outbox (topic, payload)
+    values (
+      'post.created',
+      ${JSON.stringify({
+        postId: content.postId,
+        threadId: content.threadId,
+        forumId: content.forumId,
+        authorId: content.authorId,
+      })}::jsonb
+    )
+  `)
+}
+
+export async function rollUpAncestorCounters(db: Database, postId: number): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const claimed = await tx.execute(sql`
+      insert into content_counter_rollups (post_id)
+      select p.id from posts p
+       where p.id = ${postId} and p.visibility = 'visible'
+      on conflict (post_id) do nothing
+      returning post_id
+    `)
+    if (resultRows(claimed).length === 0) return false
+
+    const found = await tx.execute(sql`
+      select p.thread_id, p.forum_id, p.author_user_id, p.author_username,
+             p.created_at, p.is_first_post, t.title as thread_title
+        from posts p
+        join threads t on t.id = p.thread_id
+       where p.id = ${postId}
+    `)
+    const post = resultRows(found)[0] as
+      | {
+          thread_id: number
+          forum_id: number
+          author_user_id: number | null
+          author_username: string
+          created_at: Date
+          is_first_post: boolean
+          thread_title: string
+        }
+      | undefined
+    if (!post) return false
+
+    const ancestorNewer = sql`f.last_post_at is null or f.last_post_id is null
+      or f.last_post_at < ${post.created_at}
+      or (f.last_post_at = ${post.created_at} and f.last_post_id < ${postId})`
+
+    await tx.execute(sql`
+      update forums f
+         set post_count = f.post_count + 1,
+             thread_count = f.thread_count + ${post.is_first_post ? 1 : 0},
+             last_post_id = case when ${ancestorNewer} then ${postId} else f.last_post_id end,
+             last_post_thread_id = case when ${ancestorNewer} then ${post.thread_id} else f.last_post_thread_id end,
+             last_post_thread_title = case when ${ancestorNewer} then ${post.thread_title} else f.last_post_thread_title end,
+             last_post_user_id = case when ${ancestorNewer} then ${post.author_user_id} else f.last_post_user_id end,
+             last_post_username = case when ${ancestorNewer} then ${post.author_username} else f.last_post_username end,
+             last_post_at = case when ${ancestorNewer} then ${post.created_at} else f.last_post_at end,
+             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
+  })
+}
+
+export class PostgresContentCounterRepository {
+  constructor(private readonly db: Database) {}
+
+  async recordCreated(content: CreatedContent): Promise<void> {
+    await this.db.transaction((tx) => applyCreatedContentCounters(tx, content))
+  }
+
+  async rollUpAncestors(postId: number): Promise<boolean> {
+    return rollUpAncestorCounters(this.db, postId)
+  }
+
+  async applyVisibilityChange(postId: number): Promise<boolean> {
+    return applyAncestorVisibilityChange(this.db, postId)
+  }
+}