@meith/db 0.16.0

package/src/task-repo.ts

@@ -0,0 +1,104 @@
+import { sql } from 'drizzle-orm'
+
+import type { TaskRepository } from '@meith/tasks'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { taskLog, tasks } from './schema'
+
+const NEVER_RUN = new Date(0)
+
+export class PostgresTaskRepository implements TaskRepository {
+  constructor(private readonly db: Database) {}
+
+  async ensureRegistered(
+    definitions: readonly { id: string; intervalSeconds: number }[],
+  ): Promise<void> {
+    if (definitions.length === 0) return
+
+    await this.db
+      .insert(tasks)
+      .values(
+        definitions.map((d) => ({
+          key: d.id,
+          intervalSeconds: d.intervalSeconds,
+          nextRunAt: NEVER_RUN,
+        })),
+      )
+      .onConflictDoUpdate({
+        target: tasks.key,
+        set: {
+          intervalSeconds: sql`excluded.interval_seconds`,
+          nextRunAt: sql`
+            case when ${tasks.intervalSeconds} is distinct from excluded.interval_seconds
+                 then coalesce(${tasks.lastRunAt}, now())
+                      + make_interval(secs => excluded.interval_seconds)
+                 else ${tasks.nextRunAt}
+            end
+          `,
+        },
+      })
+  }
+
+  async claim(input: {
+    taskId: string
+    now: Date
+    staleBefore: Date
+  }): Promise<{ previousLastRunAt: Date | null } | null> {
+    const leaseMs = input.now.getTime() - input.staleBefore.getTime()
+    const lockedUntil = new Date(input.now.getTime() + leaseMs)
+
+    const result = await this.db.execute(sql`
+      with previous as (
+        select key, last_run_at from tasks where key = ${input.taskId}
+      )
+      update tasks as t
+         set locked_until = ${lockedUntil},
+             last_run_at  = ${input.now}
+        from previous p
+       where t.key = p.key
+         and t.enabled
+         and (t.locked_until is null or t.locked_until <= ${input.now})
+         and t.next_run_at <= ${input.now}
+      returning p.last_run_at as previous_last_run_at
+    `)
+
+    const row = resultRows<{ previous_last_run_at: Date | string | null }>(result)[0]
+    if (!row) return null
+
+    const previous = row.previous_last_run_at
+    return {
+      previousLastRunAt:
+        previous === null ? null : previous instanceof Date ? previous : new Date(previous),
+    }
+  }
+
+  async release(input: {
+    taskId: string
+    finishedAt: Date
+    success: boolean
+    detail?: Record<string, unknown>
+    error?: string
+  }): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`
+        update tasks
+           set locked_until = null,
+               -- Explicit cast: an untyped bind parameter leaves Postgres
+               -- unable to resolve timestamp-plus-interval at parse time.
+               next_run_at = ${input.finishedAt}::timestamptz
+                             + make_interval(secs => interval_seconds),
+               consecutive_failures = ${input.success ? sql`0` : sql`consecutive_failures + 1`}
+         where key = ${input.taskId}
+      `)
+
+      await tx.insert(taskLog).values({
+        taskKey: input.taskId,
+        succeeded: input.success,
+        detail: input.detail === undefined ? null : JSON.stringify(input.detail),
+        error: input.error ?? null,
+        ranAt: input.finishedAt,
+      })
+    })
+  }
+}

package/src/theme-admin-repo.ts

@@ -0,0 +1,172 @@
+import { sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export interface ThemeRecord {
+  readonly key: string
+  readonly title: string
+  readonly tokenOverrides: unknown
+  readonly customCss: string | null
+  readonly enabled: boolean
+  readonly isDefault: boolean
+  readonly updatedAt: Date | null
+}
+
+export interface ThemeExport {
+  readonly version: 2
+  readonly key: string
+  readonly tokenOverrides: unknown
+  readonly customCss: string | null
+}
+
+export class PostgresThemeAdminRepository {
+  constructor(private readonly db: Database) {}
+
+  async list(): Promise<readonly ThemeRecord[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select key, title, token_overrides, custom_css, enabled, is_default, updated_at
+          from themes order by key
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map(toRecord)
+  }
+
+  async read(key: string): Promise<ThemeRecord | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select key, title, token_overrides, custom_css, enabled, is_default, updated_at
+          from themes where key = ${key}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    return row === undefined ? null : toRecord(row)
+  }
+
+  async save(input: {
+    readonly key: string
+    readonly title: string
+    readonly tokenOverrides: unknown
+    readonly customCss: string | null
+  }): Promise<void> {
+    if (input.key.trim() === '') throw new ValidationError(msg('error.db.such-theme'))
+
+    await this.db.execute(sql`
+      insert into themes (key, title, token_overrides, custom_css, updated_at)
+      values (${input.key}, ${input.title},
+              ${JSON.stringify(input.tokenOverrides ?? {})}::jsonb, ${input.customCss}, now())
+      on conflict (key) do update
+         set title = excluded.title,
+             token_overrides = excluded.token_overrides,
+             custom_css = excluded.custom_css,
+             updated_at = now()
+    `)
+  }
+
+  async setEnabled(key: string, enabled: boolean, title: string): Promise<void> {
+    if (key.trim() === '') throw new ValidationError(msg('error.db.such-theme'))
+
+    await this.db.execute(sql`
+      insert into themes (key, title, enabled, updated_at)
+      values (${key}, ${title}, ${enabled}, now())
+      on conflict (key) do update set enabled = excluded.enabled, updated_at = now()
+    `)
+  }
+
+  async setDefault(key: string, title: string): Promise<void> {
+    if (key.trim() === '') throw new ValidationError(msg('error.db.such-theme'))
+
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`update themes set is_default = false where is_default`)
+      await tx.execute(sql`
+        insert into themes (key, title, is_default, enabled, updated_at)
+        values (${key}, ${title}, true, true, now())
+        on conflict (key) do update
+           set is_default = true, enabled = true, updated_at = now()
+      `)
+    })
+  }
+
+  async reset(key: string): Promise<void> {
+    await this.db.execute(sql`
+      update themes set token_overrides = '{}'::jsonb, custom_css = null, updated_at = now()
+       where key = ${key}
+    `)
+    await this.db.execute(sql`
+      delete from themes where key = ${key} and enabled and not is_default
+    `)
+  }
+
+  async exportTheme(key: string): Promise<ThemeExport> {
+    const record = await this.read(key)
+    return {
+      version: 2,
+      key,
+      tokenOverrides: record?.tokenOverrides ?? {},
+      customCss: record?.customCss ?? null,
+    }
+  }
+}
+
+export function parseThemeExport(raw: string): {
+  readonly tokenOverrides: Readonly<Record<string, unknown>>
+  readonly customCss: string | null
+} {
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    throw new ValidationError(msg('error.db.valid-json'))
+  }
+
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    throw new ValidationError(msg('error.db.theme-file-json-object'))
+  }
+
+  const document = parsed as Record<string, unknown>
+  if (document.version !== 1 && document.version !== 2) {
+    throw new ValidationError(msg('error.db.theme-file-written-by-different'))
+  }
+
+  const tokens = document.tokenOverrides
+  if (typeof tokens !== 'object' || tokens === null || Array.isArray(tokens)) {
+    throw new ValidationError(msg('error.db.theme-file-needs-tokenoverrides-object'))
+  }
+
+  const css = document.customCss
+  if (css !== null && css !== undefined && typeof css !== 'string') {
+    throw new ValidationError(msg('error.db.customcss-must-text-null'))
+  }
+
+  return {
+    tokenOverrides: tokens as Record<string, unknown>,
+    customCss: typeof css === 'string' ? css : null,
+  }
+}
+
+function toRecord(row: Record<string, unknown>): ThemeRecord {
+  const overrides = row.token_overrides
+  return {
+    key: String(row.key),
+    title: String(row.title),
+    tokenOverrides:
+      typeof overrides === 'object' && overrides !== null && !Array.isArray(overrides)
+        ? overrides
+        : {},
+    customCss: row.custom_css === null ? null : String(row.custom_css),
+    enabled: row.enabled !== false,
+    isDefault: row.is_default === true,
+    updatedAt:
+      row.updated_at === null || row.updated_at === undefined
+        ? null
+        : row.updated_at instanceof Date
+          ? row.updated_at
+          : new Date(String(row.updated_at)),
+  }
+}

package/src/theme-repo.ts

@@ -0,0 +1,43 @@
+import { eq } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { themes } from './schema'
+
+export interface ThemeRuntimeRecord {
+  readonly tokenOverrides: unknown
+  readonly customCss: string | null
+}
+
+export interface ThemeRuntimeState extends ThemeRuntimeRecord {
+  readonly key: string
+  readonly enabled: boolean
+  readonly isDefault: boolean
+}
+
+export class PostgresThemeRepository {
+  constructor(private readonly db: Database) {}
+
+  async findRuntimeByKey(key: string): Promise<ThemeRuntimeRecord | null> {
+    const rows = await this.db
+      .select({ tokenOverrides: themes.tokenOverrides, customCss: themes.customCss })
+      .from(themes)
+      .where(eq(themes.key, key))
+      .limit(1)
+
+    return rows[0] ?? null
+  }
+
+  async listRuntime(): Promise<readonly ThemeRuntimeState[]> {
+    const rows = await this.db
+      .select({
+        key: themes.key,
+        tokenOverrides: themes.tokenOverrides,
+        customCss: themes.customCss,
+        enabled: themes.enabled,
+        isDefault: themes.isDefault,
+      })
+      .from(themes)
+
+    return rows
+  }
+}

package/src/thread-audience.ts

@@ -0,0 +1,45 @@
+import { type SQL, sql } from 'drizzle-orm'
+import type { PgColumn } from 'drizzle-orm/pg-core'
+
+import {
+  audienceForumIds,
+  audienceIsEmpty,
+  type ThreadAudience,
+  type ThreadAuthorFilter,
+} from '@meith/core'
+
+import { idList } from './sql-lists'
+
+export function authoredBy(column: PgColumn | SQL, filter: ThreadAuthorFilter): SQL {
+  switch (filter.kind) {
+    case 'all':
+      return sql`true`
+    case 'none':
+      return sql`false`
+    case 'author':
+      return sql`${column} = ${filter.userId}`
+  }
+}
+
+export function inAudience(
+  forumColumn: PgColumn | SQL,
+  authorColumn: PgColumn | SQL,
+  audience: ThreadAudience,
+): SQL {
+  if (audienceIsEmpty(audience)) return sql`false`
+
+  const { open, ownThreadsOnly } = audienceForumIds(audience)
+  const parts: SQL[] = []
+
+  if (open.length > 0) parts.push(sql`${forumColumn} in ${idList(open)}`)
+  if (ownThreadsOnly.length > 0) {
+    parts.push(
+      sql`(${forumColumn} in ${idList(ownThreadsOnly)}
+           and ${authorColumn} = ${audience.viewerUserId})`,
+    )
+  }
+
+  return sql`(${sql.join(parts, sql` or `)})`
+}
+
+export { audienceIsEmpty }

package/src/thread-counters.ts

@@ -0,0 +1,107 @@
+import { sql } from 'drizzle-orm'
+
+import { resultRows } from './result-rows'
+
+export interface CounterTx {
+  execute(query: ReturnType<typeof sql>): Promise<unknown>
+}
+
+export interface ThreadTally {
+  readonly posts: number
+  readonly byAuthor: ReadonlyArray<{ userId: number; posts: number }>
+  readonly threadAuthorId: number | null
+}
+
+export async function tallyThread(tx: CounterTx, threadId: number): Promise<ThreadTally> {
+  const rows = resultRows(
+    await tx.execute(sql`
+      select p.author_user_id, count(*)::int as n
+        from posts p
+       where p.thread_id = ${threadId} and p.visibility = 'visible'
+       group by p.author_user_id
+    `),
+  ) as Array<{ author_user_id: number | null; n: number }>
+
+  const owner = resultRows(
+    await tx.execute(sql`select author_user_id from threads where id = ${threadId}`),
+  ) as Array<{ author_user_id: number | null }>
+
+  return {
+    posts: rows.reduce((total, row) => total + Number(row.n), 0),
+    byAuthor: rows.flatMap((row) =>
+      row.author_user_id === null
+        ? []
+        : [{ userId: Number(row.author_user_id), posts: Number(row.n) }],
+    ),
+    threadAuthorId: owner[0]?.author_user_id == null ? null : Number(owner[0].author_user_id),
+  }
+}
+
+export async function applyForumChain(
+  tx: CounterTx,
+  forumId: number,
+  delta: 1 | -1,
+  tally: ThreadTally,
+): Promise<void> {
+  await tx.execute(sql`
+    update forums f
+       set post_count = greatest(f.post_count + ${delta * tally.posts}, 0),
+           thread_count = greatest(f.thread_count + ${delta}, 0),
+           updated_at = now()
+      from forums child
+     where child.id = ${forumId}
+       and (f.id = child.id or child.path like f.path || '.%')
+  `)
+}
+
+export async function applyAuthorCounts(
+  tx: CounterTx,
+  delta: 1 | -1,
+  tally: ThreadTally,
+): Promise<void> {
+  for (const author of tally.byAuthor) {
+    await tx.execute(sql`
+      update users
+         set post_count = greatest(post_count + ${delta * author.posts}, 0),
+             updated_at = now()
+       where id = ${author.userId}
+    `)
+  }
+  if (tally.threadAuthorId !== null) {
+    await tx.execute(sql`
+      update users
+         set thread_count = greatest(thread_count + ${delta}, 0), updated_at = now()
+       where id = ${tally.threadAuthorId}
+    `)
+  }
+}
+
+export async function syncLedger(tx: CounterTx, threadId: number, counted: boolean): Promise<void> {
+  if (counted) {
+    await tx.execute(sql`
+      insert into content_counter_rollups (post_id)
+      select p.id from posts p
+       where p.thread_id = ${threadId} and p.visibility = 'visible'
+      on conflict (post_id) do nothing
+    `)
+    return
+  }
+  await tx.execute(sql`
+    delete from content_counter_rollups r
+     using posts p
+     where r.post_id = p.id and p.thread_id = ${threadId}
+  `)
+}
+
+export async function logModeratorAction(
+  tx: CounterTx,
+  action: string,
+  actorUserId: number,
+  detail: Record<string, unknown>,
+  at: Date,
+): Promise<void> {
+  await tx.execute(sql`
+    insert into admin_log (user_id, action, detail, created_at)
+    values (${actorUserId}, ${action}, ${JSON.stringify(detail)}::jsonb, ${at})
+  `)
+}