@meith/db 0.16.0

package/src/profile-field-repo.ts

@@ -0,0 +1,182 @@
+import { sql } from 'drizzle-orm'
+
+import {
+  type FieldType,
+  type ProfileFieldDefinition,
+  type ProfileFieldGroupRule,
+  type ProfileFieldRepository,
+  type ProfileFieldValue,
+  parseFieldType,
+} from '@meith/profile-fields'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+interface RawField {
+  id: number
+  key: string
+  label: string
+  description: string | null
+  type: string
+  options: unknown
+  max_length: number | null
+  display_order: number
+  is_active: boolean
+  required_at_registration: boolean
+  default_visible: boolean
+  default_editable: boolean
+  show_in_postbit: boolean
+}
+
+function toOptions(value: unknown): readonly string[] {
+  if (!Array.isArray(value)) return []
+  return value.filter((entry): entry is string => typeof entry === 'string')
+}
+
+function toField(row: RawField): ProfileFieldDefinition {
+  return {
+    id: Number(row.id),
+    key: row.key,
+    label: row.label,
+    description: row.description,
+    type: parseFieldType(row.type),
+    options: toOptions(row.options),
+    maxLength: row.max_length === null ? null : Number(row.max_length),
+    displayOrder: Number(row.display_order),
+    isActive: row.is_active === true,
+    requiredAtRegistration: row.required_at_registration === true,
+    defaultVisible: row.default_visible === true,
+    defaultEditable: row.default_editable === true,
+    showInPostbit: row.show_in_postbit === true,
+  }
+}
+
+const SELECT_FIELD = sql`
+  select id, key, label, description, type, options, max_length, display_order,
+         is_active, required_at_registration, default_visible, default_editable,
+         show_in_postbit
+    from profile_fields
+`
+
+export class PostgresProfileFieldRepository implements ProfileFieldRepository {
+  constructor(private readonly db: Database) {}
+
+  async listFields(): Promise<readonly ProfileFieldDefinition[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`${SELECT_FIELD} order by display_order, id`),
+    ) as RawField[]
+
+    return rows.map(toField)
+  }
+
+  async listGroupRules(): Promise<readonly ProfileFieldGroupRule[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select field_id, group_id, can_view, can_edit from profile_field_groups
+      `),
+    ) as Array<{
+      field_id: number
+      group_id: number
+      can_view: boolean | null
+      can_edit: boolean | null
+    }>
+
+    return rows.map((row) => ({
+      fieldId: Number(row.field_id),
+      groupId: Number(row.group_id),
+      canView: row.can_view,
+      canEdit: row.can_edit,
+    }))
+  }
+
+  async valuesFor(userId: number): Promise<readonly ProfileFieldValue[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select field_id, value from profile_field_values where user_id = ${userId}
+      `),
+    ) as Array<{ field_id: number; value: string }>
+
+    return rows.map((row) => ({ fieldId: Number(row.field_id), value: row.value }))
+  }
+
+  async saveValues(input: {
+    readonly userId: number
+    readonly values: readonly ProfileFieldValue[]
+  }): Promise<void> {
+    if (input.values.length === 0) return
+
+    await this.db.transaction(async (tx) => {
+      const cleared = input.values.filter((value) => value.value === '')
+      const written = input.values.filter((value) => value.value !== '')
+
+      if (cleared.length > 0) {
+        await tx.execute(sql`
+          delete from profile_field_values
+           where user_id = ${input.userId}
+             and field_id in (${sql.join(
+               cleared.map((value) => sql`${value.fieldId}`),
+               sql`, `,
+             )})
+        `)
+      }
+
+      if (written.length > 0) {
+        await tx.execute(sql`
+          insert into profile_field_values (user_id, field_id, value, updated_at)
+          values ${sql.join(
+            written.map((value) => sql`(${input.userId}, ${value.fieldId}, ${value.value}, now())`),
+            sql`, `,
+          )}
+              on conflict (user_id, field_id)
+              do update set value = excluded.value, updated_at = now()
+        `)
+      }
+    })
+  }
+
+  async findByKey(key: string): Promise<ProfileFieldDefinition | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`${SELECT_FIELD} where key = ${key}`),
+    ) as RawField[]
+
+    return rows[0] === undefined ? null : toField(rows[0])
+  }
+
+  async create(input: {
+    readonly key: string
+    readonly label: string
+    readonly type: FieldType
+    readonly options: readonly string[]
+    readonly requiredAtRegistration: boolean
+    readonly showInPostbit: boolean
+    readonly displayOrder: number
+  }): Promise<ProfileFieldDefinition> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into profile_fields
+               (key, label, type, options, required_at_registration,
+                show_in_postbit, display_order)
+        values (${input.key}, ${input.label}, ${input.type},
+                ${JSON.stringify(input.options)}::jsonb,
+                ${input.requiredAtRegistration}, ${input.showInPostbit},
+                ${input.displayOrder})
+        returning id, key, label, description, type, options, max_length,
+                  display_order, is_active, required_at_registration,
+                  default_visible, default_editable, show_in_postbit
+      `),
+    ) as RawField[]
+
+    if (rows[0] === undefined) throw new Error('Profile field insert returned no row')
+    return toField(rows[0])
+  }
+
+  async remove(key: string): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from profile_fields where key = ${key} returning id
+      `),
+    ) as Array<{ id: number }>
+
+    return rows.length > 0
+  }
+}

package/src/promotion-repo.ts

@@ -0,0 +1,152 @@
+import { asc, eq, gt, sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import type {
+  PromotionCandidate,
+  PromotionOutcome,
+  PromotionRepository,
+  PromotionRule,
+  PromotionRuleInput,
+  PromotionRuleRepository,
+} from '@meith/groups'
+import { promotionRuleProblem } from '@meith/groups'
+import { msg } from '@meith/i18n'
+
+import type { Database } from './client'
+import { groupPromotions, users } from './schema'
+import { keptDisplayGroupSql } from './staff-groups'
+
+function optionalNumber(value: number | null): number | undefined {
+  return value === null ? undefined : value
+}
+
+function checked(input: PromotionRuleInput): PromotionRuleInput {
+  const problem = promotionRuleProblem(input)
+  if (problem !== null) throw new ValidationError(problem)
+  return { ...input, title: input.title.trim() }
+}
+
+export class PostgresPromotionRepository implements PromotionRepository, PromotionRuleRepository {
+  constructor(private readonly db: Database) {}
+
+  async listRules(): Promise<readonly PromotionRule[]> {
+    const rows = await this.db
+      .select()
+      .from(groupPromotions)
+      .orderBy(asc(groupPromotions.displayOrder), asc(groupPromotions.id))
+
+    return rows.map((r) => ({
+      id: r.id,
+      title: r.title,
+      enabled: r.enabled,
+      displayOrder: r.displayOrder,
+      minPostCount: optionalNumber(r.minPostCount),
+      minReputation: optionalNumber(r.minReputation),
+      minDaysRegistered: optionalNumber(r.minDaysRegistered),
+      fromPrimaryGroupId: r.fromPrimaryGroupId,
+      toPrimaryGroupId: r.toPrimaryGroupId,
+    }))
+  }
+
+  async createRule(input: PromotionRuleInput): Promise<number> {
+    const rule = checked(input)
+
+    const [row] = await this.db
+      .insert(groupPromotions)
+      .values({
+        title: rule.title,
+        displayOrder: rule.displayOrder,
+        minPostCount: rule.minPostCount,
+        minReputation: rule.minReputation,
+        minDaysRegistered: rule.minDaysRegistered,
+        fromPrimaryGroupId: rule.fromPrimaryGroupId,
+        toPrimaryGroupId: rule.toPrimaryGroupId,
+      })
+      .returning({ id: groupPromotions.id })
+
+    if (row === undefined) throw new ValidationError(msg('error.db.rule-could-stored'))
+    return row.id
+  }
+
+  async updateRule(id: number, input: PromotionRuleInput): Promise<void> {
+    const rule = checked(input)
+
+    const rows = await this.db
+      .update(groupPromotions)
+      .set({
+        title: rule.title,
+        displayOrder: rule.displayOrder,
+        minPostCount: rule.minPostCount,
+        minReputation: rule.minReputation,
+        minDaysRegistered: rule.minDaysRegistered,
+        fromPrimaryGroupId: rule.fromPrimaryGroupId,
+        toPrimaryGroupId: rule.toPrimaryGroupId,
+        updatedAt: new Date(),
+      })
+      .where(eq(groupPromotions.id, id))
+      .returning({ id: groupPromotions.id })
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-promotion-rule'))
+  }
+
+  async setRuleEnabled(id: number, enabled: boolean): Promise<void> {
+    const rows = await this.db
+      .update(groupPromotions)
+      .set({ enabled, updatedAt: new Date() })
+      .where(eq(groupPromotions.id, id))
+      .returning({ id: groupPromotions.id })
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-promotion-rule'))
+  }
+
+  async deleteRule(id: number): Promise<void> {
+    await this.db.delete(groupPromotions).where(eq(groupPromotions.id, id))
+  }
+
+  async candidates(afterUserId: number, limit: number): Promise<readonly PromotionCandidate[]> {
+    const rows = await this.db
+      .select({
+        userId: users.id,
+        postCount: users.postCount,
+        reputation: users.reputation,
+        registeredAt: users.createdAt,
+        primaryGroupId: users.primaryGroupId,
+      })
+      .from(users)
+      .where(gt(users.id, afterUserId))
+      .orderBy(asc(users.id))
+      .limit(limit)
+
+    return rows
+  }
+
+  async applyPromotions(outcomes: readonly PromotionOutcome[]): Promise<void> {
+    if (outcomes.length === 0) return
+
+    await this.db.transaction(async (tx) => {
+      const values = sql.join(
+        outcomes.map((o) => sql`(${o.userId}::int, ${o.toPrimaryGroupId}::int)`),
+        sql`, `,
+      )
+
+      const displayGroup = keptDisplayGroupSql({
+        column: sql.raw('u.display_group_id'),
+        leavingGroupId: sql.raw('u.primary_group_id'),
+        arrivingGroupId: sql.raw('v.group_id'),
+      })
+
+      await tx.execute(sql`
+        update ${users} as u
+        set primary_group_id = v.group_id, display_group_id = ${displayGroup}
+        from (values ${values}) as v(user_id, group_id)
+        where u.id = v.user_id
+      `)
+
+      await tx.execute(sql`
+        insert into cache_versions (key, version)
+        values ('permissions', 1)
+        on conflict (key) do update set version = cache_versions.version + 1, bumped_at = now()
+      `)
+    })
+  }
+}

package/src/read-state-repo.ts

@@ -0,0 +1,81 @@
+import { and, eq, gt, isNull, or, sql } from 'drizzle-orm'
+
+import { PUBLIC_CONTENT } from '@meith/core'
+import type { ReadState, ReadStateRepository } from '@meith/threads'
+
+import type { Database } from './client'
+import { forumsRead, threads, threadsRead } from './schema'
+import { visibleIn } from './visibility'
+
+export class PostgresReadStateRepository implements ReadStateRepository {
+  constructor(private readonly db: Database) {}
+
+  async forUser(userId: number): Promise<ReadState> {
+    const [forums, threadReads, unread] = await Promise.all([
+      this.db
+        .select({ forumId: forumsRead.forumId, readAt: forumsRead.readAt })
+        .from(forumsRead)
+        .where(eq(forumsRead.userId, userId)),
+      this.db
+        .select({ threadId: threadsRead.threadId, lastReadPostId: threadsRead.lastReadPostId })
+        .from(threadsRead)
+        .where(eq(threadsRead.userId, userId)),
+      this.db
+        .selectDistinct({ forumId: threads.forumId })
+        .from(threads)
+        .leftJoin(
+          forumsRead,
+          and(eq(forumsRead.userId, userId), eq(forumsRead.forumId, threads.forumId)),
+        )
+        .leftJoin(
+          threadsRead,
+          and(eq(threadsRead.userId, userId), eq(threadsRead.threadId, threads.id)),
+        )
+        .where(
+          and(
+            visibleIn(threads.visibility, PUBLIC_CONTENT),
+            sql`${threads.lastPostId} is not null`,
+            or(
+              isNull(threadsRead.lastReadPostId),
+              gt(threads.lastPostId, threadsRead.lastReadPostId),
+            ),
+            or(isNull(forumsRead.readAt), gt(threads.lastPostAt, forumsRead.readAt)),
+          ),
+        ),
+    ])
+
+    return {
+      forumReadAt: new Map(forums.map((row) => [row.forumId, row.readAt])),
+      threadLastPostId: new Map(
+        threadReads.flatMap((row) =>
+          row.lastReadPostId === null ? [] : [[row.threadId, row.lastReadPostId] as const],
+        ),
+      ),
+      unreadForumIds: new Set(unread.map((row) => row.forumId)),
+    }
+  }
+
+  async markForumsRead(userId: number, forumIds: readonly number[], at: Date): Promise<void> {
+    if (forumIds.length === 0) return
+    await this.db
+      .insert(forumsRead)
+      .values(forumIds.map((forumId) => ({ userId, forumId, readAt: at })))
+      .onConflictDoUpdate({
+        target: [forumsRead.userId, forumsRead.forumId],
+        set: { readAt: at },
+      })
+  }
+
+  async markThreadRead(userId: number, threadId: number, postId: number, at: Date): Promise<void> {
+    await this.db
+      .insert(threadsRead)
+      .values({ userId, threadId, lastReadPostId: postId, readAt: at })
+      .onConflictDoUpdate({
+        target: [threadsRead.userId, threadsRead.threadId],
+        set: {
+          lastReadPostId: sql`greatest(coalesce(${threadsRead.lastReadPostId}, 0), excluded.last_read_post_id)`,
+          readAt: at,
+        },
+      })
+  }
+}

package/src/relation-repo.ts

@@ -0,0 +1,113 @@
+import { sql } from 'drizzle-orm'
+
+import type { RelationKind, RelationRepository, RelationRow } from '@meith/relations'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate, toNullableDate } from './row-values'
+
+export class PostgresRelationRepository implements RelationRepository {
+  constructor(private readonly db: Database) {}
+
+  async list(input: {
+    readonly userId: number
+    readonly kind: RelationKind
+  }): Promise<readonly RelationRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select r.other_user_id, r.kind, r.created_at, u.username, u.last_active_at
+          from user_relations r
+          join users u on u.id = r.other_user_id
+         where r.user_id = ${input.userId}
+           and r.kind = ${input.kind}
+           /*
+            * A deleted account is not on anybody's list. The row survives by
+            * design — deleted_at is a tombstone, not a removal — but showing
+            * a name the board no longer recognises anywhere else would be a
+            * list somebody cannot act on.
+            */
+           and u.deleted_at is null
+         order by u.username
+      `),
+    ) as Array<{
+      other_user_id: number
+      kind: string
+      created_at: string | Date
+      username: string
+      last_active_at: string | Date | null
+    }>
+
+    return rows.map((row) => ({
+      userId: Number(row.other_user_id),
+      username: row.username,
+      kind: row.kind as RelationKind,
+      lastActiveAt: toNullableDate(row.last_active_at),
+      createdAt: toDate(row.created_at),
+    }))
+  }
+
+  async count(userId: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as n from user_relations where user_id = ${userId}
+      `),
+    ) as Array<{ n: number }>
+
+    return Number(rows[0]?.n ?? 0)
+  }
+
+  async ignoredIds(userId: number): Promise<readonly number[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select other_user_id from user_relations
+         where user_id = ${userId} and kind = 'ignore'
+      `),
+    ) as Array<{ other_user_id: number }>
+
+    return rows.map((row) => Number(row.other_user_id))
+  }
+
+  async set(input: {
+    readonly userId: number
+    readonly otherUserId: number
+    readonly kind: RelationKind
+    readonly at: Date
+  }): Promise<void> {
+    await this.db.execute(sql`
+      insert into user_relations (user_id, other_user_id, kind, created_at)
+      values (${input.userId}, ${input.otherUserId}, ${input.kind}, ${input.at})
+          on conflict (user_id, other_user_id)
+          /*
+           * The kind is replaced; created_at is not. "On my list since" is a
+           * property of the relationship, not of the last time somebody changed
+           * their mind about which list it belongs on.
+           */
+          do update set kind = excluded.kind
+    `)
+  }
+
+  async remove(input: { readonly userId: number; readonly otherUserId: number }): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from user_relations
+         where user_id = ${input.userId} and other_user_id = ${input.otherUserId}
+        returning user_id
+      `),
+    ) as Array<{ user_id: number }>
+
+    return rows.length > 0
+  }
+
+  async ignores(ownerUserId: number, otherUserId: number): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select 1 as hit from user_relations
+         where user_id = ${ownerUserId}
+           and other_user_id = ${otherUserId}
+           and kind = 'ignore'
+      `),
+    ) as Array<{ hit: number }>
+
+    return rows.length > 0
+  }
+}

package/src/render-backfill.ts

@@ -0,0 +1,110 @@
+import { sql } from 'drizzle-orm'
+
+import {
+  authorRef,
+  BodyFormat,
+  CORE_RENDERING,
+  type MarkdownPipeline,
+  RENDER_VERSION,
+  renderThrough,
+  sourceAsMarkdown,
+  vocabularyOptions,
+} from '@meith/markdown'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { readBoardVocabulary } from './vocabulary-repo'
+
+export interface RenderBackfillRun {
+  readonly rendered: number
+  readonly converted: number
+}
+
+export class PostgresRenderBackfill {
+  constructor(
+    private readonly db: Database,
+    private readonly rendering: MarkdownPipeline = CORE_RENDERING,
+  ) {}
+
+  async pending(): Promise<number> {
+    const vocabulary = await readBoardVocabulary(this.db, this.rendering)
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as pending
+          from posts
+         where render_version <> ${RENDER_VERSION}
+            or vocab_version <> ${vocabulary.revision}
+            or body_format <> ${BodyFormat.Markdown}
+      `),
+    ) as Array<{ pending: number }>
+    return Number(rows[0]?.pending ?? 0)
+  }
+
+  async run(batchSize: number): Promise<RenderBackfillRun> {
+    if (batchSize <= 0) return { rendered: 0, converted: 0 }
+
+    const vocabulary = await readBoardVocabulary(this.db, this.rendering)
+
+    const stale = resultRows(
+      await this.db.execute(sql`
+        select id, message, body_format, author_user_id
+          from posts
+         where render_version <> ${RENDER_VERSION}
+            or vocab_version <> ${vocabulary.revision}
+            or body_format <> ${BodyFormat.Markdown}
+         order by id
+         limit ${batchSize}
+      `),
+    ) as Array<{
+      id: number
+      message: string
+      body_format: number
+      author_user_id: number | null
+    }>
+
+    if (stale.length === 0) return { rendered: 0, converted: 0 }
+
+    const rendered = await Promise.all(
+      stale.map(async (row) => {
+        const format = Number(row.body_format)
+        const message = sourceAsMarkdown(row.message, format)
+        const body = await renderThrough(
+          this.rendering,
+          message,
+          {
+            source: 'post',
+            viewer: authorRef(row.author_user_id === null ? null : Number(row.author_user_id)),
+            postId: Number(row.id),
+          },
+          vocabularyOptions(vocabulary),
+        )
+        return {
+          id: Number(row.id),
+          message,
+          html: body.html,
+          converted: format !== BodyFormat.Markdown,
+        }
+      }),
+    )
+
+    const values = sql.join(
+      rendered.map((row) => sql`(${row.id}::int, ${row.message}::text, ${row.html}::text)`),
+      sql`, `,
+    )
+    await this.db.execute(sql`
+      update posts as p
+         set message = v.message,
+             message_html = v.html,
+             render_version = ${RENDER_VERSION},
+             vocab_version = ${vocabulary.revision},
+             body_format = ${BodyFormat.Markdown}
+        from (values ${values}) as v(id, message, html)
+       where p.id = v.id
+    `)
+
+    return {
+      rendered: rendered.length,
+      converted: rendered.filter((row) => row.converted).length,
+    }
+  }
+}

package/src/render-signature.ts

@@ -0,0 +1,33 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+const SIGNATURE_KEY = 'plugin_render'
+const VOCABULARY_KEY = 'markdown_vocabulary'
+
+export async function syncRenderSignature(db: Database, signature: number): Promise<boolean> {
+  return db.transaction(async (tx) => {
+    const rows = resultRows(
+      await tx.execute(sql`select version from cache_versions where key = ${SIGNATURE_KEY}`),
+    ) as Array<{ version: number }>
+
+    const recorded = rows[0] === undefined ? null : Number(rows[0].version)
+    if (recorded === signature) return false
+
+    await tx.execute(sql`
+      insert into cache_versions (key, version) values (${SIGNATURE_KEY}, ${signature})
+      on conflict (key) do update set version = ${signature}, bumped_at = now()
+    `)
+
+    if (recorded === null) return false
+
+    await tx.execute(sql`
+      insert into cache_versions (key, version) values (${VOCABULARY_KEY}, 1)
+      on conflict (key)
+        do update set version = cache_versions.version + 1, bumped_at = now()
+    `)
+
+    return true
+  })
+}