@meith/db 0.16.0

package/src/stats-repo.ts

@@ -0,0 +1,151 @@
+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 { audienceIsEmpty, inAudience } from './thread-audience'
+import { visibleIn } from './visibility'
+
+export interface BoardTotals {
+  readonly threadCount: number
+  readonly postCount: number
+  readonly memberCount: number
+  readonly newestUserId: number | null
+  readonly newestUsername: string | null
+  readonly computedAt: Date | null
+}
+
+export interface TopPoster {
+  readonly userId: number
+  readonly username: string
+  readonly postCount: number
+}
+
+export interface TopThread {
+  readonly threadId: number
+  readonly title: string
+  readonly slug: string
+  readonly forumId: number
+  readonly forumTitle: string
+  readonly viewCount: number
+  readonly replyCount: number
+}
+
+export interface StatsScope {
+  readonly forumIds: readonly number[]
+  readonly ownThreadsOnlyForumIds: readonly number[]
+  readonly viewerUserId: number | null
+  readonly content: ContentScope
+}
+
+export class PostgresStatsRepository {
+  constructor(private readonly db: Database) {}
+
+  async readTotals(): Promise<BoardTotals> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select thread_count, post_count, member_count,
+               newest_user_id, newest_username, computed_at
+          from board_stats where id = 1
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    if (row === undefined) {
+      return {
+        threadCount: 0,
+        postCount: 0,
+        memberCount: 0,
+        newestUserId: null,
+        newestUsername: null,
+        computedAt: null,
+      }
+    }
+
+    return {
+      threadCount: Number(row.thread_count),
+      postCount: Number(row.post_count),
+      memberCount: Number(row.member_count),
+      newestUserId: row.newest_user_id === null ? null : Number(row.newest_user_id),
+      newestUsername: row.newest_username === null ? null : String(row.newest_username),
+      computedAt: row.computed_at === null ? null : toDate(row.computed_at),
+    }
+  }
+
+  async rollUp(now: Date): Promise<BoardTotals> {
+    await this.db.execute(sql`
+      update board_stats set
+        thread_count = coalesce((select sum(thread_count) from forums where parent_id is null), 0),
+        post_count = coalesce((select sum(post_count) from forums where parent_id is null), 0),
+        member_count = (select count(*) from users where state = 'active'),
+        newest_user_id = (select id from users where state = 'active'
+                           order by created_at desc, id desc limit 1),
+        newest_username = (select username from users where state = 'active'
+                            order by created_at desc, id desc limit 1),
+        computed_at = ${now},
+        updated_at = ${now}
+      where id = 1
+    `)
+
+    return this.readTotals()
+  }
+
+  async topPosters(limit: number): Promise<readonly TopPoster[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, username, post_count
+          from users
+         where state = 'active' and post_count > 0
+         order by post_count desc, id
+         limit ${limit}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      userId: Number(row.id),
+      username: String(row.username),
+      postCount: Number(row.post_count),
+    }))
+  }
+
+  async mostViewed(limit: number, scope: StatsScope): Promise<readonly TopThread[]> {
+    return this.topThreads(sql`t.view_count desc, t.id`, limit, scope)
+  }
+
+  async mostReplied(limit: number, scope: StatsScope): Promise<readonly TopThread[]> {
+    return this.topThreads(sql`t.reply_count desc, t.id`, limit, scope)
+  }
+
+  private async topThreads(
+    order: ReturnType<typeof sql>,
+    limit: number,
+    scope: StatsScope,
+  ): Promise<readonly TopThread[]> {
+    if (audienceIsEmpty(scope)) return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select t.id, t.title, t.slug, t.forum_id, f.title as forum_title,
+               t.view_count, t.reply_count
+          from threads t
+          join forums f on f.id = t.forum_id
+         where ${inAudience(sql`t.forum_id`, sql`t.author_user_id`, scope)}
+           and ${visibleIn(sql`t.visibility`, scope.content)}
+         order by ${order}
+         limit ${limit}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      threadId: Number(row.id),
+      title: String(row.title),
+      slug: String(row.slug),
+      forumId: Number(row.forum_id),
+      forumTitle: String(row.forum_title),
+      viewCount: Number(row.view_count),
+      replyCount: Number(row.reply_count),
+    }))
+  }
+}

package/src/subscription-repo.ts

@@ -0,0 +1,350 @@
+import { sql } from 'drizzle-orm'
+
+import { PUBLIC_CONTENT } from '@meith/core'
+import type {
+  DigestCadence,
+  PendingForUser,
+  SubscriptionMode,
+  SubscriptionRepository,
+  SubscriptionRow,
+  SubscriptionTarget,
+} from '@meith/subscriptions'
+import { parseSubscriptionMode } from '@meith/subscriptions'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+import { idList } from './sql-lists'
+import { visibleIn } from './visibility'
+
+interface TableShape {
+  readonly table: ReturnType<typeof sql>
+  readonly column: ReturnType<typeof sql>
+}
+
+function shapeFor(target: SubscriptionTarget): TableShape {
+  return target === 'thread'
+    ? { table: sql`thread_subscriptions`, column: sql`thread_id` }
+    : { table: sql`forum_subscriptions`, column: sql`forum_id` }
+}
+
+function pendingPosts(
+  userId: number,
+  mode: SubscriptionMode | null,
+  visibleForumIds: readonly number[] | null,
+): ReturnType<typeof sql> {
+  const byMode = mode === null ? sql`` : sql`and s.mode = ${mode}`
+  const visible =
+    visibleForumIds === null ? sql`` : sql`and t.forum_id in ${idList(visibleForumIds)}`
+
+  return sql`
+    select p.id as post_id, p.thread_id, t.title as thread_title, t.slug as thread_slug,
+           t.forum_id, u.username as author_username, p.created_at,
+           'thread'::text as target, s.thread_id as target_id
+      from thread_subscriptions s
+      join threads t on t.id = s.thread_id
+      join posts p on p.thread_id = s.thread_id and p.id > s.last_notified_post_id
+      left join users u on u.id = p.author_user_id
+     where s.user_id = ${userId} ${byMode}
+       and p.author_user_id is distinct from ${userId}
+       and ${visibleIn(sql`p.visibility`, PUBLIC_CONTENT)}
+       and ${visibleIn(sql`t.visibility`, PUBLIC_CONTENT)}
+       ${visible}
+
+    union all
+
+    select p.id as post_id, p.thread_id, t.title as thread_title, t.slug as thread_slug,
+           t.forum_id, u.username as author_username, p.created_at,
+           'forum'::text as target, s.forum_id as target_id
+      from forum_subscriptions s
+      join threads t on t.forum_id = s.forum_id
+      join posts p on p.thread_id = t.id and p.id > s.last_notified_post_id
+      left join users u on u.id = p.author_user_id
+     where s.user_id = ${userId} ${byMode}
+       and p.author_user_id is distinct from ${userId}
+       and ${visibleIn(sql`p.visibility`, PUBLIC_CONTENT)}
+       and ${visibleIn(sql`t.visibility`, PUBLIC_CONTENT)}
+       ${visible}
+  `
+}
+
+interface RawPending {
+  post_id: number
+  thread_id: number
+  thread_title: string
+  thread_slug: string
+  forum_id: number
+  author_username: string | null
+  created_at: string | Date
+  target: SubscriptionTarget
+  target_id: number
+}
+
+export class PostgresSubscriptionRepository implements SubscriptionRepository {
+  constructor(private readonly db: Database) {}
+
+  async subscribe(input: {
+    readonly userId: number
+    readonly target: SubscriptionTarget
+    readonly targetId: number
+    readonly mode: SubscriptionMode
+    readonly at: Date
+  }): Promise<boolean> {
+    const rows = resultRows(
+      input.target === 'thread'
+        ? await this.db.execute(sql`
+            insert into thread_subscriptions
+                   (user_id, thread_id, mode, last_notified_post_id, created_at)
+            select ${input.userId}, t.id, ${input.mode},
+                   coalesce(t.last_post_id, 0), ${input.at}
+              from threads t
+             where t.id = ${input.targetId}
+                on conflict (user_id, thread_id)
+                do update set mode = excluded.mode
+            returning user_id
+          `)
+        : await this.db.execute(sql`
+            insert into forum_subscriptions
+                   (user_id, forum_id, mode, last_notified_post_id, created_at)
+            select ${input.userId}, f.id, ${input.mode},
+                   coalesce(f.last_post_id, 0), ${input.at}
+              from forums f
+             where f.id = ${input.targetId}
+                on conflict (user_id, forum_id)
+                do update set mode = excluded.mode
+            returning user_id
+          `),
+    ) as Array<{ user_id: number }>
+
+    return rows.length > 0
+  }
+
+  async unsubscribe(input: {
+    readonly userId: number
+    readonly target: SubscriptionTarget
+    readonly targetId: number
+  }): Promise<boolean> {
+    const { table, column } = shapeFor(input.target)
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from ${table}
+         where user_id = ${input.userId} and ${column} = ${input.targetId}
+        returning user_id
+      `),
+    ) as Array<{ user_id: number }>
+
+    return rows.length > 0
+  }
+
+  async modeFor(
+    userId: number,
+    target: SubscriptionTarget,
+    targetId: number,
+  ): Promise<SubscriptionMode | null> {
+    const { table, column } = shapeFor(target)
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select mode from ${table}
+         where user_id = ${userId} and ${column} = ${targetId}
+      `),
+    ) as Array<{ mode: string }>
+
+    const stored = rows[0]?.mode
+    return stored === undefined ? null : parseSubscriptionMode(stored)
+  }
+
+  async listFor(
+    userId: number,
+    options: { readonly visibleForumIds: readonly number[]; readonly limit: number },
+  ): Promise<readonly SubscriptionRow[]> {
+    const visible = idList(options.visibleForumIds)
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        with pending as (
+          select target, target_id, count(*)::int as pending
+            from (${pendingPosts(userId, null, options.visibleForumIds)}) p
+           group by target, target_id
+        )
+        select 'thread'::text as target, s.thread_id as target_id, t.title,
+               t.slug, s.mode, s.created_at,
+               coalesce(pending.pending, 0) as pending
+          from thread_subscriptions s
+          join threads t on t.id = s.thread_id
+          left join pending
+                 on pending.target = 'thread' and pending.target_id = s.thread_id
+         where s.user_id = ${userId}
+           and ${visibleIn(sql`t.visibility`, PUBLIC_CONTENT)}
+           and t.forum_id in ${visible}
+
+        union all
+
+        select 'forum'::text as target, s.forum_id as target_id, f.title,
+               f.slug, s.mode, s.created_at,
+               coalesce(pending.pending, 0) as pending
+          from forum_subscriptions s
+          join forums f on f.id = s.forum_id
+          left join pending
+                 on pending.target = 'forum' and pending.target_id = s.forum_id
+         where s.user_id = ${userId} and s.forum_id in ${visible}
+
+         order by created_at desc, target_id desc
+         limit ${options.limit}
+      `),
+    ) as Array<{
+      target: SubscriptionTarget
+      target_id: number
+      title: string
+      slug: string
+      mode: string
+      created_at: string | Date
+      pending: number
+    }>
+
+    return rows.map((row) => ({
+      target: row.target,
+      targetId: Number(row.target_id),
+      title: row.title,
+      href:
+        row.target === 'thread'
+          ? `/thread/${Number(row.target_id)}-${row.slug}`
+          : `/${Number(row.target_id)}-${row.slug}`,
+      mode: parseSubscriptionMode(row.mode) ?? 'instant',
+      createdAt: toDate(row.created_at),
+      pending: Number(row.pending),
+    }))
+  }
+
+  async usersWithPending(input: {
+    readonly mode: SubscriptionMode
+    readonly dueBefore: Date | null
+    readonly limit: number
+  }): Promise<readonly number[]> {
+    const cadence = input.dueBefore === null ? null : input.mode
+    const dueClause =
+      input.dueBefore === null || cadence === null
+        ? sql``
+        : sql`
+            and not exists (
+              select 1 from digest_runs d
+               where d.user_id = s.user_id and d.cadence = ${cadence}
+                 and d.last_sent_at > ${input.dueBefore}
+            )
+          `
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select distinct s.user_id
+          from (
+            select user_id, thread_id as target_id, mode, last_notified_post_id,
+                   'thread'::text as target
+              from thread_subscriptions
+             union all
+            select user_id, forum_id as target_id, mode, last_notified_post_id,
+                   'forum'::text as target
+              from forum_subscriptions
+          ) s
+         where s.mode = ${input.mode}
+           and exists (
+             select 1
+               from threads t
+               join posts p on p.thread_id = t.id and p.id > s.last_notified_post_id
+              where (
+                      (s.target = 'thread' and t.id = s.target_id)
+                   or (s.target = 'forum' and t.forum_id = s.target_id)
+                    )
+                and p.author_user_id is distinct from s.user_id
+                and ${visibleIn(sql`p.visibility`, PUBLIC_CONTENT)}
+                and ${visibleIn(sql`t.visibility`, PUBLIC_CONTENT)}
+           )
+           ${dueClause}
+         order by s.user_id
+         limit ${input.limit}
+      `),
+    ) as Array<{ user_id: number }>
+
+    return rows.map((row) => Number(row.user_id))
+  }
+
+  async pendingFor(input: {
+    readonly userId: number
+    readonly mode: SubscriptionMode
+    readonly visibleForumIds: readonly number[]
+    readonly limit: number
+  }): Promise<PendingForUser> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select * from (${pendingPosts(input.userId, input.mode, input.visibleForumIds)}) p
+         order by p.thread_id, p.post_id
+         limit ${input.limit}
+      `),
+    ) as RawPending[]
+
+    const highest = new Map<
+      string,
+      { target: SubscriptionTarget; targetId: number; lastPostId: number }
+    >()
+    for (const row of rows) {
+      const key = `${row.target}:${row.target_id}`
+      const current = highest.get(key)
+      const postId = Number(row.post_id)
+      if (current === undefined || postId > current.lastPostId) {
+        highest.set(key, {
+          target: row.target,
+          targetId: Number(row.target_id),
+          lastPostId: postId,
+        })
+      }
+    }
+
+    const seen = new Set<number>()
+    const posts = []
+    for (const row of rows) {
+      const postId = Number(row.post_id)
+      if (seen.has(postId)) continue
+      seen.add(postId)
+      posts.push({
+        postId,
+        threadId: Number(row.thread_id),
+        threadTitle: row.thread_title,
+        threadSlug: row.thread_slug,
+        forumId: Number(row.forum_id),
+        authorUsername: row.author_username,
+        createdAt: toDate(row.created_at),
+      })
+    }
+
+    return { userId: input.userId, posts, watermarks: [...highest.values()] }
+  }
+
+  async advanceWatermarks(input: {
+    readonly userId: number
+    readonly watermarks: PendingForUser['watermarks']
+  }): Promise<void> {
+    if (input.watermarks.length === 0) return
+
+    await this.db.transaction(async (tx) => {
+      for (const mark of input.watermarks) {
+        const { table, column } = shapeFor(mark.target)
+        await tx.execute(sql`
+          update ${table}
+             set last_notified_post_id = greatest(last_notified_post_id, ${mark.lastPostId})
+           where user_id = ${input.userId} and ${column} = ${mark.targetId}
+        `)
+      }
+    })
+  }
+
+  async recordDigestRun(input: {
+    readonly userId: number
+    readonly cadence: DigestCadence
+    readonly at: Date
+  }): Promise<void> {
+    await this.db.execute(sql`
+      insert into digest_runs (user_id, cadence, last_sent_at)
+      values (${input.userId}, ${input.cadence}, ${input.at})
+          on conflict (user_id, cadence)
+          do update set last_sent_at = excluded.last_sent_at
+    `)
+  }
+}

package/src/system-health-repo.ts

@@ -0,0 +1,130 @@
+import { sql } from 'drizzle-orm'
+
+import type { TaskHealthInput } from '@meith/tasks'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+
+export interface TaskRunRow {
+  readonly taskKey: string
+  readonly succeeded: boolean
+  readonly durationMs: number | null
+  readonly detail: string | null
+  readonly error: string | null
+  readonly ranAt: Date
+}
+
+export interface RecountStateRow {
+  readonly id: string
+  readonly phase: string
+  readonly cursor: number
+  readonly passes: number
+  readonly corrected: number
+  readonly updatedAt: Date | null
+}
+
+export interface BoardVolumes {
+  readonly users: number
+  readonly threads: number
+  readonly posts: number
+  readonly attachments: number
+  readonly queuedJobs: number
+  readonly deadLetteredJobs: number
+}
+
+export class PostgresSystemHealthRepository {
+  constructor(private readonly db: Database) {}
+
+  async taskHealth(): Promise<readonly TaskHealthInput[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select key, interval_seconds, enabled, last_run_at, next_run_at,
+               consecutive_failures
+          from tasks order by key
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      key: String(row.key),
+      intervalSeconds: Number(row.interval_seconds),
+      enabled: row.enabled === true,
+      lastRunAt: row.last_run_at === null ? null : toDate(row.last_run_at),
+      nextRunAt: row.next_run_at === null ? null : toDate(row.next_run_at),
+      consecutiveFailures: Number(row.consecutive_failures),
+    }))
+  }
+
+  async recentRuns(limit = 20): Promise<readonly TaskRunRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select task_key, succeeded, duration_ms, detail, error, ran_at
+          from task_log order by ran_at desc, id desc limit ${limit}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      taskKey: String(row.task_key),
+      succeeded: row.succeeded === true,
+      durationMs: row.duration_ms === null ? null : Number(row.duration_ms),
+      detail: row.detail === null ? null : String(row.detail),
+      error: row.error === null ? null : String(row.error),
+      ranAt: toDate(row.ran_at),
+    }))
+  }
+
+  async recountState(): Promise<readonly RecountStateRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, phase, cursor, passes, corrected, updated_at
+          from counter_recount_state order by id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      id: String(row.id),
+      phase: String(row.phase),
+      cursor: Number(row.cursor),
+      passes: Number(row.passes),
+      corrected: Number(row.corrected),
+      updatedAt: row.updated_at === null ? null : toDate(row.updated_at),
+    }))
+  }
+
+  async volumes(): Promise<BoardVolumes> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select
+          (select count(*) from users where deleted_at is null)::int as users,
+          (select count(*) from threads)::int as threads,
+          (select count(*) from posts)::int as posts,
+          (select count(*) from attachments)::int as attachments,
+          (select count(*) from jobs where status in ('pending', 'running'))::int
+            as queued_jobs,
+          (select count(*) from jobs where status = 'dead')::int as dead_lettered
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0] as Record<string, unknown>
+    return {
+      users: Number(row.users),
+      threads: Number(row.threads),
+      posts: Number(row.posts),
+      attachments: Number(row.attachments),
+      queuedJobs: Number(row.queued_jobs),
+      deadLetteredJobs: Number(row.dead_lettered),
+    }
+  }
+
+  async activeConnections(): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as active
+          from pg_stat_activity
+         where datname = current_database()
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return Number(rows[0]?.active ?? 0)
+  }
+}