@meith/db 0.16.0

package/src/plugin-health-repo.ts

@@ -0,0 +1,80 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export interface PluginHealthRecord {
+  readonly pluginKey: string
+  readonly failures: number
+  readonly disabledAt: Date | null
+  readonly reason: string | null
+}
+
+function toRecord(row: Record<string, unknown>): PluginHealthRecord {
+  return {
+    pluginKey: String(row.plugin_key),
+    failures: Number(row.failures),
+    disabledAt: row.disabled_at === null ? null : new Date(row.disabled_at as string),
+    reason: row.reason === null ? null : String(row.reason),
+  }
+}
+
+export async function readPluginHealth(db: Database): Promise<readonly PluginHealthRecord[]> {
+  const rows = resultRows(
+    await db.execute(sql`
+      select plugin_key, failures, disabled_at, reason
+        from plugin_health
+       order by plugin_key
+    `),
+  ) as Array<Record<string, unknown>>
+
+  return rows.map(toRecord)
+}
+
+export async function recordPluginFailure(
+  db: Database,
+  input: {
+    readonly pluginKey: string
+    readonly threshold: number
+    readonly reason: string
+  },
+): Promise<PluginHealthRecord> {
+  const rows = resultRows(
+    await db.execute(sql`
+      insert into plugin_health (plugin_key, failures, disabled_at, reason, updated_at)
+      values (
+        ${input.pluginKey},
+        1,
+        case when 1 >= ${input.threshold} then now() else null end,
+        case when 1 >= ${input.threshold} then ${input.reason} else null end,
+        now()
+      )
+      on conflict (plugin_key) do update
+        set failures = plugin_health.failures + 1,
+            disabled_at = case
+              when plugin_health.disabled_at is not null then plugin_health.disabled_at
+              when plugin_health.failures + 1 >= ${input.threshold} then now()
+              else null
+            end,
+            reason = case
+              when plugin_health.disabled_at is not null then plugin_health.reason
+              when plugin_health.failures + 1 >= ${input.threshold} then ${input.reason}
+              else null
+            end,
+            updated_at = now()
+      returning plugin_key, failures, disabled_at, reason
+    `),
+  ) as Array<Record<string, unknown>>
+
+  return toRecord(rows[0]!)
+}
+
+export async function clearPluginHealth(db: Database, pluginKey: string): Promise<boolean> {
+  const rows = resultRows(
+    await db.execute(sql`
+      delete from plugin_health where plugin_key = ${pluginKey} returning plugin_key
+    `),
+  ) as Array<Record<string, unknown>>
+
+  return rows.length > 0
+}

package/src/plugin-purge-repo.ts

@@ -0,0 +1,91 @@
+import { sql } from 'drizzle-orm'
+
+import { pluginTablePrefix } from '@meith/plugin-kit'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export interface PluginPurgeResult {
+  readonly tables: readonly string[]
+  readonly settings: number
+  readonly migrations: number
+  readonly navigation: number
+  readonly versionRemoved: boolean
+  readonly healthRemoved: boolean
+}
+
+export async function pluginOwnedTables(
+  db: Database,
+  pluginKey: string,
+): Promise<readonly string[]> {
+  const rows = resultRows(
+    await db.execute(sql`
+      select table_name
+        from information_schema.tables
+       where table_schema = 'public'
+         and table_type = 'BASE TABLE'
+         and table_name like ${`${pluginTablePrefix(pluginKey)}%`}
+       order by table_name
+    `),
+  ) as Array<{ table_name: string }>
+
+  return rows.map((row) => String(row.table_name))
+}
+
+/**
+ * Everything a plugin left behind, taken away in one transaction.
+ *
+ * The tables are found by prefix rather than from the plugin's own migration
+ * list, because the list says what it meant to create and the schema says what
+ * it did. The prefix is safe to trust: `definePlugin` refuses a migration that
+ * names anything outside it, so nothing the board owns can match.
+ */
+export async function purgePlugin(db: Database, pluginKey: string): Promise<PluginPurgeResult> {
+  const tables = await pluginOwnedTables(db, pluginKey)
+
+  return db.transaction(async (tx) => {
+    for (const table of tables) {
+      await tx.execute(sql.raw(`drop table if exists "${table}" cascade`))
+    }
+
+    const settings = resultRows(
+      await tx.execute(sql`
+        delete from settings where key like ${`plugin.${pluginKey}.%`} returning key
+      `),
+    ) as Array<unknown>
+
+    const migrations = resultRows(
+      await tx.execute(sql`
+        delete from plugin_migrations where plugin_key = ${pluginKey} returning migration_id
+      `),
+    ) as Array<unknown>
+
+    const navigation = resultRows(
+      await tx.execute(sql`
+        delete from navigation_items where key like ${`plugin.${pluginKey}.%`} returning id
+      `),
+    ) as Array<unknown>
+
+    const version = resultRows(
+      await tx.execute(sql`
+        delete from component_versions where component = ${`plugin:${pluginKey}`}
+        returning component
+      `),
+    ) as Array<unknown>
+
+    const health = resultRows(
+      await tx.execute(sql`
+        delete from plugin_health where plugin_key = ${pluginKey} returning plugin_key
+      `),
+    ) as Array<unknown>
+
+    return {
+      tables,
+      settings: settings.length,
+      migrations: migrations.length,
+      navigation: navigation.length,
+      versionRemoved: version.length > 0,
+      healthRemoved: health.length > 0,
+    }
+  })
+}

package/src/plugin-users.ts

@@ -0,0 +1,39 @@
+import { and, eq, ne } from 'drizzle-orm'
+
+import type { PluginUserRef, PluginUsers } from '@meith/plugin-kit'
+
+import type { Database } from './client'
+import { users } from './schema'
+
+const REF = { userId: users.id, username: users.username } as const
+
+export function pluginUsers(db: Database): PluginUsers {
+  const first = (rows: readonly PluginUserRef[]): PluginUserRef | null => rows[0] ?? null
+
+  return {
+    async byUsername(username) {
+      const needle = username.trim().toLowerCase()
+      if (needle === '') return null
+
+      return first(
+        await db
+          .select(REF)
+          .from(users)
+          .where(and(eq(users.usernameLower, needle), ne(users.state, 'deleted')))
+          .limit(1),
+      )
+    },
+
+    async byId(userId) {
+      if (!Number.isSafeInteger(userId) || userId <= 0) return null
+
+      return first(
+        await db
+          .select(REF)
+          .from(users)
+          .where(and(eq(users.id, userId), ne(users.state, 'deleted')))
+          .limit(1),
+      )
+    },
+  }
+}

package/src/poll-repo.ts

@@ -0,0 +1,334 @@
+import { type SQL, sql } from 'drizzle-orm'
+
+import {
+  POLL_CHOICES_UNLIMITED,
+  POLL_VOTERS_SHOWN_MAX,
+  type Poll,
+  type PollEditPlan,
+  type PollRepository,
+  type PollVote,
+  type PollVoter,
+  type ThreadRating,
+  type ThreadRatingRepository,
+  type ValidatedPoll,
+} from '@meith/polls'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+function date(value: Date | string | null): Date | null {
+  return value === null ? null : value instanceof Date ? value : new Date(value)
+}
+
+function ids(values: readonly number[]): SQL {
+  return sql.join(
+    values.map((value) => sql`${value}`),
+    sql`, `,
+  )
+}
+
+export class PostgresPollRepository implements PollRepository, ThreadRatingRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(threadId: number, poll: ValidatedPoll): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      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 id = rows[0]?.id
+      if (id === 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`(${id}, ${label}, ${index})`),
+          sql`, `,
+        )}
+      `)
+    })
+  }
+
+  async find(threadId: number, voterUserId: number | null): Promise<Poll | null> {
+    const polls = resultRows(
+      await this.db.execute(sql`
+        select id, question, closes_at, created_at, max_options, allow_revote, public_votes
+          from polls where thread_id = ${threadId}
+      `),
+    ) as Array<{
+      id: number
+      question: string
+      closes_at: Date | string | null
+      created_at: Date | string
+      max_options: number
+      allow_revote: boolean
+      public_votes: boolean
+    }>
+    const poll = polls[0]
+    if (poll === undefined) return null
+
+    const [options, votes, voters] = await Promise.all([
+      this.db.execute(sql`
+        select id, label, vote_count from poll_options
+         where poll_id = ${poll.id} order by display_order, id
+      `),
+      voterUserId === null
+        ? Promise.resolve([])
+        : this.db.execute(sql`
+            select option_id from poll_votes
+             where poll_id = ${poll.id} and user_id = ${voterUserId}
+          `),
+      poll.public_votes ? this.voters(Number(poll.id)) : Promise.resolve(new Map()),
+    ])
+    const voteRows = resultRows(votes) as Array<{ option_id: number }>
+    const byOption = voters as Map<number, PollVoter[]>
+
+    return {
+      id: Number(poll.id),
+      threadId,
+      question: poll.question,
+      closesAt: date(poll.closes_at),
+      createdAt: date(poll.created_at) ?? new Date(0),
+      maxOptions: Number(poll.max_options),
+      allowRevote: poll.allow_revote === true,
+      publicVotes: poll.public_votes === true,
+      options: (
+        resultRows(options) as Array<{
+          id: number
+          label: string
+          vote_count: number
+        }>
+      ).map((row) => ({
+        id: Number(row.id),
+        label: row.label,
+        votes: Number(row.vote_count),
+        voters: byOption.get(Number(row.id)) ?? [],
+      })),
+      votedOptionIds: voteRows.map((row) => Number(row.option_id)),
+    }
+  }
+
+  private async voters(pollId: number): Promise<Map<number, PollVoter[]>> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select o.id as option_id, v.user_id, u.username, v.created_at
+          from poll_options o
+          join lateral (
+            select pv.user_id, pv.created_at from poll_votes pv
+             where pv.poll_id = o.poll_id and pv.option_id = o.id
+             order by pv.created_at, pv.user_id limit ${POLL_VOTERS_SHOWN_MAX}
+          ) v on true
+          join users u on u.id = v.user_id
+         where o.poll_id = ${pollId}
+         order by o.display_order, o.id, v.created_at, v.user_id
+      `),
+    ) as Array<{
+      option_id: number
+      user_id: number
+      username: string
+      created_at: Date | string | null
+    }>
+
+    const byOption = new Map<number, PollVoter[]>()
+    for (const row of rows) {
+      const optionId = Number(row.option_id)
+      const list = byOption.get(optionId) ?? []
+      list.push({
+        userId: Number(row.user_id),
+        username: row.username,
+        votedAt: date(row.created_at),
+      })
+      byOption.set(optionId, list)
+    }
+    return byOption
+  }
+
+  async vote(input: PollVote): Promise<boolean> {
+    const wanted = [...new Set(input.optionIds)]
+    if (wanted.length === 0) return false
+
+    return this.db.transaction(async (tx) => {
+      const polls = resultRows(
+        await tx.execute(sql`
+          select id, max_options, allow_revote from polls
+           where id = ${input.pollId} and thread_id = ${input.threadId}
+             and (closes_at is null or closes_at > now())
+           for update
+        `),
+      ) as Array<{ id: number; max_options: number; allow_revote: boolean }>
+      const poll = polls[0]
+      if (poll === undefined) return false
+
+      const maxOptions = Number(poll.max_options)
+      if (maxOptions !== POLL_CHOICES_UNLIMITED && wanted.length > maxOptions) return false
+
+      const chosen = resultRows(
+        await tx.execute(sql`
+          select id from poll_options
+           where poll_id = ${poll.id} and id in (${ids(wanted)})
+        `),
+      )
+      if (chosen.length !== wanted.length) return false
+
+      const previous = resultRows(
+        await tx.execute(sql`
+          select option_id from poll_votes
+           where poll_id = ${poll.id} and user_id = ${input.userId}
+        `),
+      ) as Array<{ option_id: number }>
+
+      if (previous.length > 0) {
+        if (poll.allow_revote !== true) return false
+        await tx.execute(sql`
+          delete from poll_votes where poll_id = ${poll.id} and user_id = ${input.userId}
+        `)
+        await tx.execute(sql`
+          update poll_options set vote_count = greatest(0, vote_count - 1)
+           where poll_id = ${poll.id}
+             and id in (${ids(previous.map((row) => Number(row.option_id)))})
+        `)
+      }
+
+      await tx.execute(sql`
+        insert into poll_votes (poll_id, user_id, option_id)
+        values ${sql.join(
+          wanted.map((optionId) => sql`(${poll.id}, ${input.userId}, ${optionId})`),
+          sql`, `,
+        )}
+      `)
+      await tx.execute(sql`
+        update poll_options set vote_count = vote_count + 1
+         where poll_id = ${poll.id} and id in (${ids(wanted)})
+      `)
+      return true
+    })
+  }
+
+  async applyEdit(plan: PollEditPlan): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const polls = resultRows(
+        await tx.execute(sql`
+          select id, public_votes from polls where id = ${plan.pollId} for update
+        `),
+      ) as Array<{ id: number; public_votes: boolean }>
+      const poll = polls[0]
+      if (poll === undefined) return false
+
+      const kept = plan.options.map((option) => option.id).filter((id): id is number => id !== null)
+      const known = resultRows(
+        await tx.execute(sql`
+          select id from poll_options where poll_id = ${poll.id}
+        `),
+      ) as Array<{ id: number }>
+      const existing = new Set(known.map((row) => Number(row.id)))
+      if (kept.some((id) => !existing.has(id))) return false
+
+      const cast = resultRows(
+        await tx.execute(sql`
+          select option_id from poll_votes where poll_id = ${poll.id}
+        `),
+      ) as Array<{ option_id: number }>
+
+      const removed = [...existing].filter((id) => !kept.includes(id))
+      if (removed.some((id) => cast.some((row) => Number(row.option_id) === id))) return false
+      if (plan.publicVotes && poll.public_votes !== true && cast.length > 0) return false
+
+      if (removed.length > 0) {
+        await tx.execute(sql`
+          delete from poll_options where poll_id = ${poll.id} and id in (${ids(removed)})
+        `)
+      }
+
+      if (kept.length > 0) {
+        await tx.execute(sql`
+          update poll_options set display_order = -1 - display_order where poll_id = ${poll.id}
+        `)
+      }
+
+      let order = 0
+      for (const option of plan.options) {
+        if (option.id === null) {
+          await tx.execute(sql`
+            insert into poll_options (poll_id, label, display_order)
+            values (${poll.id}, ${option.label}, ${order})
+          `)
+        } else {
+          await tx.execute(sql`
+            update poll_options set label = ${option.label}, display_order = ${order}
+             where poll_id = ${poll.id} and id = ${option.id}
+          `)
+        }
+        order += 1
+      }
+
+      await tx.execute(sql`
+        update polls set question = ${plan.question}, closes_at = ${plan.closesAt},
+                         max_options = ${plan.maxOptions}, allow_revote = ${plan.allowRevote},
+                         public_votes = ${plan.publicVotes}
+         where id = ${poll.id}
+      `)
+      return true
+    })
+  }
+
+  async rate(input: {
+    readonly threadId: number
+    readonly userId: number
+    readonly rating: number
+  }): Promise<ThreadRating | null> {
+    return this.db.transaction(async (tx) => {
+      const locked = resultRows(
+        await tx.execute(sql`select id from threads where id = ${input.threadId} for update`),
+      )
+      if (locked.length === 0) return null
+      const previous = resultRows(
+        await tx.execute(sql`
+          select rating from thread_ratings where thread_id = ${input.threadId} and user_id = ${input.userId}
+        `),
+      ) as Array<{ rating: number }>
+      await tx.execute(sql`
+        insert into thread_ratings (thread_id, user_id, rating, updated_at)
+        values (${input.threadId}, ${input.userId}, ${input.rating}, now())
+        on conflict (thread_id, user_id) do update set rating = excluded.rating, updated_at = excluded.updated_at
+      `)
+      const prior = Number(previous[0]?.rating ?? 0)
+      const rows = resultRows(
+        await tx.execute(sql`
+          update threads set rating_total = rating_total + ${input.rating - prior},
+                             rating_count = rating_count + ${previous.length === 0 ? 1 : 0}
+           where id = ${input.threadId}
+           returning rating_total, rating_count
+        `),
+      ) as Array<{ rating_total: number; rating_count: number }>
+      const row = rows[0]!
+      return {
+        average: Number(row.rating_total) / Number(row.rating_count),
+        count: Number(row.rating_count),
+        mine: input.rating,
+      }
+    })
+  }
+
+  async findRating(threadId: number, userId: number | null): Promise<ThreadRating | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select t.rating_total, t.rating_count, r.rating as mine
+          from threads t left join thread_ratings r on r.thread_id = t.id and r.user_id = ${userId}
+         where t.id = ${threadId}
+      `),
+    ) as Array<{
+      rating_total: number
+      rating_count: number
+      mine: number | null
+    }>
+    const row = rows[0]
+    if (row === undefined) return null
+    return {
+      average: row.rating_count === 0 ? 0 : Number(row.rating_total) / Number(row.rating_count),
+      count: Number(row.rating_count),
+      mine: row.mine === null ? null : Number(row.mine),
+    }
+  }
+}