@meith/db 0.31.0 → 0.32.0

package/src/feed-token-repo.ts

@@ -0,0 +1,103 @@
+import { sql } from 'drizzle-orm'
+
+import type { FeedTokenRecord } from '@meith/api'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+
+export interface FeedTokenSummary {
+  readonly userId: number
+  readonly lookup: string
+  readonly createdAt: Date
+  readonly lastUsedAt: Date | null
+}
+
+const TOUCH_INTERVAL_MS = 60_000
+
+export class PostgresFeedTokenRepository {
+  constructor(private readonly db: Database) {}
+
+  async findByLookup(lookup: string): Promise<FeedTokenRecord | null> {
+    const rows = resultRows<{
+      id: number
+      user_id: number
+      lookup: string
+      secret_hash: string
+    }>(
+      await this.db.execute(sql`
+        select id, user_id, lookup, secret_hash
+        from feed_tokens
+        where lookup = ${lookup}
+        limit 1
+      `),
+    )
+
+    const row = rows[0]
+    if (row === undefined) return null
+
+    return {
+      id: Number(row.id),
+      userId: Number(row.user_id),
+      lookup: row.lookup,
+      secretHash: row.secret_hash,
+    }
+  }
+
+  async summaryForUser(userId: number): Promise<FeedTokenSummary | null> {
+    const rows = resultRows<{
+      user_id: number
+      lookup: string
+      created_at: Date | string
+      last_used_at: Date | string | null
+    }>(
+      await this.db.execute(sql`
+        select user_id, lookup, created_at, last_used_at
+        from feed_tokens
+        where user_id = ${userId}
+        limit 1
+      `),
+    )
+
+    const row = rows[0]
+    if (row === undefined) return null
+
+    return {
+      userId: Number(row.user_id),
+      lookup: row.lookup,
+      createdAt: toDate(row.created_at),
+      lastUsedAt: row.last_used_at === null ? null : toDate(row.last_used_at),
+    }
+  }
+
+  async regenerate(input: {
+    readonly userId: number
+    readonly lookup: string
+    readonly secretHash: string
+  }): Promise<void> {
+    await this.db.execute(sql`
+      insert into feed_tokens (user_id, lookup, secret_hash, created_at, last_used_at)
+      values (${input.userId}, ${input.lookup}, ${input.secretHash}, now(), null)
+      on conflict (user_id) do update
+        set lookup = excluded.lookup,
+            secret_hash = excluded.secret_hash,
+            created_at = now(),
+            last_used_at = null
+    `)
+  }
+
+  async revokeForUser(userId: number): Promise<void> {
+    await this.db.execute(sql`
+      delete from feed_tokens where user_id = ${userId}
+    `)
+  }
+
+  async touch(id: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update feed_tokens
+      set last_used_at = ${at}
+      where id = ${id}
+        and (last_used_at is null or last_used_at < ${new Date(at.getTime() - TOUCH_INTERVAL_MS)})
+    `)
+  }
+}

package/src/forum-admin-repo.ts

@@ -227,32 +227,57 @@ export class PostgresForumAdminRepository {
     })
   }
 
+  private async writeOverrides(
+    executor: Pick<Database, 'execute'>,
+    forumId: number,
+    groupId: number,
+    values: Readonly<Record<string, boolean | number | null>>,
+  ): Promise<void> {
+    if (FORUM_PERMISSION_FIELDS.every((field) => values[field.key] == null)) {
+      await executor.execute(sql`
+        delete from forum_permissions
+         where forum_id = ${forumId} and group_id = ${groupId}
+      `)
+      return
+    }
+
+    const columns = FORUM_PERMISSION_FIELDS.map((field) => sql.raw(columnName(field.key)))
+    const literals = FORUM_PERMISSION_FIELDS.map((field) => sql`${values[field.key] ?? null}`)
+    const assignments = FORUM_PERMISSION_FIELDS.map(
+      (field) =>
+        sql`${sql.raw(columnName(field.key))} = excluded.${sql.raw(columnName(field.key))}`,
+    )
+
+    await executor.execute(sql`
+      insert into forum_permissions (forum_id, group_id, ${sql.join(columns, sql`, `)})
+      values (${forumId}, ${groupId}, ${sql.join(literals, sql`, `)})
+      on conflict (forum_id, group_id) do update set ${sql.join(assignments, sql`, `)}
+    `)
+  }
+
   async saveOverrides(
     forumId: number,
     groupId: number,
     values: Readonly<Record<string, boolean | number | null>>,
   ): Promise<void> {
     await this.db.transaction(async (tx) => {
-      if (FORUM_PERMISSION_FIELDS.every((field) => values[field.key] == null)) {
-        await tx.execute(sql`
-          delete from forum_permissions
-           where forum_id = ${forumId} and group_id = ${groupId}
-        `)
-        return
-      }
+      await this.writeOverrides(tx, forumId, groupId, values)
+    })
+  }
 
-      const columns = FORUM_PERMISSION_FIELDS.map((field) => sql.raw(columnName(field.key)))
-      const literals = FORUM_PERMISSION_FIELDS.map((field) => sql`${values[field.key] ?? null}`)
-      const assignments = FORUM_PERMISSION_FIELDS.map(
-        (field) =>
-          sql`${sql.raw(columnName(field.key))} = excluded.${sql.raw(columnName(field.key))}`,
-      )
+  async saveOverridesForGroups(
+    forumId: number,
+    changes: readonly {
+      readonly groupId: number
+      readonly values: Readonly<Record<string, boolean | number | null>>
+    }[],
+  ): Promise<void> {
+    if (changes.length === 0) return
 
-      await tx.execute(sql`
-        insert into forum_permissions (forum_id, group_id, ${sql.join(columns, sql`, `)})
-        values (${forumId}, ${groupId}, ${sql.join(literals, sql`, `)})
-        on conflict (forum_id, group_id) do update set ${sql.join(assignments, sql`, `)}
-      `)
+    await this.db.transaction(async (tx) => {
+      for (const change of changes) {
+        await this.writeOverrides(tx, forumId, change.groupId, change.values)
+      }
     })
   }
 

package/src/index.ts

@@ -36,7 +36,10 @@ export {
   PostgresApiTokenRepository,
   PostgresRateLimitStore,
   PostgresWebhookRepository,
+  type WebhookActiveSubscription,
+  type WebhookDeliveryLogRow,
   type WebhookDeliveryRow,
+  type WebhookSummary,
 } from './api-repo'
 export {
   type AttachmentAdminFilter,
@@ -55,6 +58,7 @@ export {
   PostgresBanFilterRepository,
   PostgresBanRepository,
 } from './ban-repos'
+export { PostgresBoardDigestRepository } from './board-digest-repo'
 export {
   closeDb,
   createIsolatedDb,
@@ -97,6 +101,7 @@ export {
   type SitemapForum,
   type SitemapThread,
 } from './feed-repo'
+export { type FeedTokenSummary, PostgresFeedTokenRepository } from './feed-token-repo'
 export {
   type AppointModeratorInput,
   type ForumOptionsInput,
@@ -203,11 +208,13 @@ export {
   pluginOwnedTables,
   purgePlugin,
 } from './plugin-purge-repo'
+export { ensurePluginDataRole, pluginDbRole } from './plugin-role'
 export { pluginUsers } from './plugin-users'
 export { PostgresPollRepository } from './poll-repo'
 export { PostgresPostRepository } from './post-repo'
 export { PostgresPostWriteRepository } from './post-writes'
 export {
+  type MemberPresence,
   ONLINE_WINDOW_MINUTES,
   type OnlineMember,
   type OnlineRecord,
@@ -230,9 +237,12 @@ export { resultRows } from './result-rows'
 export * from './schema'
 export { expectedTables, missingTables } from './schema-state'
 export {
+  DEFAULT_SEARCH_CONFIG,
   indexedSubjectSql,
   PostgresSearchRepository,
   type ReindexResult,
+  readSearchConfig,
+  resolveSearchConfig,
   SEARCH_DOCUMENT_VERSION,
   SEARCH_WINDOW,
   searchVectorSql,

package/src/member-settings-repo.ts

@@ -1,6 +1,7 @@
 import { sql } from 'drizzle-orm'
 
 import type { MemberGroupChoice, MemberSettings, MemberSettingsRepository } from '@meith/accounts'
+import { parseSubscriptionMode } from '@meith/subscriptions'
 
 import type { Database } from './client'
 import { resultRows } from './result-rows'
@@ -19,6 +20,9 @@ interface RawSettings {
   bio: string | null
   display_group_id: number | null
   mass_mail_opt_in_at: Date | string | null
+  board_digest_cadence: string
+  auto_watch_own_threads: string
+  auto_watch_replied_threads: string
 }
 
 interface RawGroupChoice {
@@ -36,7 +40,8 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
       await this.db.execute(sql`
         select id, email, timezone, locale, posts_per_page, threads_per_page,
                invisible, location, website, bio, display_group_id,
-               mass_mail_opt_in_at
+               mass_mail_opt_in_at, board_digest_cadence,
+               auto_watch_own_threads, auto_watch_replied_threads
           from users
          where id = ${userId} and state <> 'deleted'
       `),
@@ -58,6 +63,9 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
       bio: row.bio,
       displayGroupId: row.display_group_id === null ? null : Number(row.display_group_id),
       massMailOptInAt: row.mass_mail_opt_in_at === null ? null : new Date(row.mass_mail_opt_in_at),
+      boardDigestCadence: row.board_digest_cadence,
+      autoWatchOwnThreads: parseSubscriptionMode(row.auto_watch_own_threads) ?? 'none',
+      autoWatchRepliedThreads: parseSubscriptionMode(row.auto_watch_replied_threads) ?? 'none',
     }
   }
 
@@ -123,6 +131,8 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
     readonly postsPerPage: number | null
     readonly threadsPerPage: number | null
     readonly invisible: boolean
+    readonly autoWatchOwnThreads: string
+    readonly autoWatchRepliedThreads: string
   }): Promise<void> {
     await this.db.execute(sql`
       update users
@@ -131,6 +141,8 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
              posts_per_page = ${input.postsPerPage},
              threads_per_page = ${input.threadsPerPage},
              invisible = ${input.invisible},
+             auto_watch_own_threads = ${input.autoWatchOwnThreads},
+             auto_watch_replied_threads = ${input.autoWatchRepliedThreads},
              updated_at = now()
        where id = ${input.userId}
     `)
@@ -150,6 +162,18 @@ export class PostgresMemberSettingsRepository implements MemberSettingsRepositor
     `)
   }
 
+  async saveBoardDigestCadence(input: {
+    readonly userId: number
+    readonly cadence: string
+  }): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set board_digest_cadence = ${input.cadence},
+             updated_at = now()
+       where id = ${input.userId} and state <> 'deleted'
+    `)
+  }
+
   async adoptEmail(input: {
     readonly userId: number
     readonly email: string

package/src/moderation-queue.ts

@@ -66,6 +66,37 @@ function toItem(row: QueueRow): QueueItem {
   }
 }
 
+async function flagHeldPosts(
+  tx: { execute(query: ReturnType<typeof sql>): Promise<unknown> },
+  threadIds: readonly number[],
+): Promise<Map<number, number[]>> {
+  const map = new Map<number, number[]>()
+  if (threadIds.length === 0) return map
+
+  const rows = resultRows(
+    await tx.execute(sql`
+      select (l.detail->>'threadId')::int as thread_id, l.detail as detail
+        from admin_log l
+       where l.action = 'post.autohold'
+         and (l.detail->>'threadId')::int in ${idList(threadIds)}
+       order by l.created_at desc, l.id desc
+    `),
+  ) as Array<{ thread_id: number; detail: Record<string, unknown> | null }>
+
+  for (const row of rows) {
+    const threadId = Number(row.thread_id)
+    if (map.has(threadId)) continue
+    const ids = row.detail?.heldPostIds
+    if (Array.isArray(ids)) {
+      map.set(
+        threadId,
+        ids.map((value) => Number(value)).filter((value) => Number.isSafeInteger(value)),
+      )
+    }
+  }
+  return map
+}
+
 export class PostgresModerationQueueRepository implements ModerationQueueRepository {
   constructor(private readonly db: Database) {}
 
@@ -183,40 +214,49 @@ export class PostgresModerationQueueRepository implements ModerationQueueReposit
       let applied = 0
       const touched = new Set<number>()
 
+      const heldByThread = await flagHeldPosts(tx, input.threadIds)
+
       for (const threadId of input.threadIds) {
         const moved = resultRows(
           await tx.execute(sql`
             update threads set visibility = ${to}, updated_at = now()
              where id = ${threadId} and visibility = ${PENDING_APPROVAL}
-             returning id, forum_id, first_post_id, author_user_id
+             returning id, forum_id, first_post_id
           `),
-        ) as Array<{
-          id: number
-          forum_id: number
-          first_post_id: number | null
-          author_user_id: number | null
-        }>
+        ) as Array<{ id: number; forum_id: number; first_post_id: number | null }>
         const thread = moved[0]
         if (!thread) continue
         applied += 1
-        touched.add(Number(thread.forum_id))
+        const forumId = Number(thread.forum_id)
+        touched.add(forumId)
+
+        const held = heldByThread.get(threadId) ?? []
+        const targetIds =
+          held.length > 0
+            ? held
+            : thread.first_post_id === null
+              ? []
+              : [Number(thread.first_post_id)]
+        if (targetIds.length === 0) continue
 
-        if (thread.first_post_id !== null) {
-          const post = resultRows(
-            await tx.execute(sql`
-              update posts set visibility = ${to}
-               where id = ${thread.first_post_id} and visibility = ${PENDING_APPROVAL}
-               returning id
-            `),
-          ) as Array<{ id: number }>
+        const posts = resultRows(
+          await tx.execute(sql`
+            update posts set visibility = ${to}
+             where thread_id = ${threadId}
+               and id in ${idList(targetIds)}
+               and visibility = ${PENDING_APPROVAL}
+             returning id, author_user_id, is_first_post
+          `),
+        ) as Array<{ id: number; author_user_id: number | null; is_first_post: boolean }>
 
-          if (post[0] && approving) {
+        if (approving) {
+          for (const post of posts) {
             await applyVisibilityChangeCounters(tx, {
-              postId: Number(post[0].id),
+              postId: Number(post.id),
               threadId: Number(thread.id),
-              forumId: Number(thread.forum_id),
-              authorId: thread.author_user_id === null ? null : Number(thread.author_user_id),
-              isFirstPost: true,
+              forumId,
+              authorId: post.author_user_id === null ? null : Number(post.author_user_id),
+              isFirstPost: post.is_first_post === true,
               delta: 1,
             })
           }

package/src/plugin-data.ts

@@ -5,6 +5,7 @@ import type { PluginData } from '@meith/plugin-kit'
 
 import type { Database } from './client'
 import type { Tx } from './permission-version'
+import { ensurePluginDataRole, pluginDbRole } from './plugin-role'
 import { resultRows } from './result-rows'
 
 export interface PluginDataOptions {
@@ -13,6 +14,21 @@ export interface PluginDataOptions {
 
 const DEFAULT_TIMEOUT_MS = 3_000
 
+const ensuredRoles = new WeakMap<Database, Set<string>>()
+
+async function ensureRoleOnce(db: Database, pluginKey: string): Promise<void> {
+  let seen = ensuredRoles.get(db)
+  if (seen === undefined) {
+    seen = new Set<string>()
+    ensuredRoles.set(db, seen)
+  }
+  if (seen.has(pluginKey)) return
+  try {
+    await db.transaction((tx) => ensurePluginDataRole(tx, pluginKey))
+  } catch {}
+  seen.add(pluginKey)
+}
+
 export function bindPluginSql(
   text: string,
   params: readonly unknown[],
@@ -66,10 +82,13 @@ export function pluginData(
 ): PluginData {
   const timeoutMs = Math.max(1, Math.trunc(options.statementTimeoutMs ?? DEFAULT_TIMEOUT_MS))
   const where = `plugin "${pluginKey}"`
+  const role = pluginDbRole(pluginKey)
 
   const inTransaction = async <T>(work: (data: PluginData) => Promise<T>): Promise<T> => {
+    await ensureRoleOnce(db, pluginKey)
     return db.transaction(async (tx) => {
       await tx.execute(sql.raw(`set local statement_timeout = ${timeoutMs}`))
+      await tx.execute(sql.raw(`set local role "${role.replace(/"/g, '""')}"`))
       return work(onExecutor(tx, where))
     })
   }

package/src/plugin-grants.ts

@@ -157,6 +157,38 @@ async function grantableGroup(
   return { id: Number(row.id), key: String(row.key) }
 }
 
+async function readableGroup(
+  db: Database,
+  pluginKey: string,
+  groupKey: string,
+): Promise<GrantableGroup | null> {
+  const rows = resultRows(
+    await db.execute(sql`select * from usergroups where key = ${groupKey} limit 1`),
+  ) as Array<Record<string, unknown>>
+
+  const row = rows[0]
+  if (row === undefined || row.plugin_grantable !== true) return null
+
+  const where = `plugin "${pluginKey}"`
+  if (row.is_system === true) {
+    throw new ValidationError(
+      `${where}: "${groupKey}" is a system group. The board resolves it by key; its membership is not a plugin's to read.`,
+    )
+  }
+  if (row.is_staff_group === true) {
+    throw new ValidationError(
+      `${where}: "${groupKey}" is a staff group, and staff standing is not a plugin's to read.`,
+    )
+  }
+  if (permissionsCarryPower(groupRowToPermissionSet(camelise(row)))) {
+    throw new ValidationError(
+      `${where}: "${groupKey}" carries administrative or moderation power, so no plugin may read its membership.`,
+    )
+  }
+
+  return { id: Number(row.id), key: String(row.key) }
+}
+
 function checkedUntil(pluginKey: string, until: Date, now: Date): Date {
   if (!(until instanceof Date) || Number.isNaN(until.getTime())) {
     throw new ValidationError(`plugin "${pluginKey}": the grant needs a valid expiry date.`)
@@ -330,6 +362,57 @@ export function pluginGrants(
         .filter((row): row is { groupKey: string; expiresAt: Date } => row.expiresAt !== null)
         .map((row): PluginGrantRow => ({ groupKey: row.groupKey, expiresAt: row.expiresAt }))
     },
+
+    async holds(userId, groupKey) {
+      const group = await readableGroup(db, pluginKey, groupKey)
+      if (group === null) return false
+
+      const now = clock()
+
+      const userRows = resultRows(
+        await db.execute(
+          sql`select primary_group_id from users where id = ${userId} and deleted_at is null limit 1`,
+        ),
+      ) as Array<{ primary_group_id: number }>
+      const user = userRows[0]
+      if (user === undefined) return false
+
+      const membershipRows = resultRows(
+        await db.execute(sql`
+          select group_id, expires_at, previous_primary_group_id
+            from user_group_memberships
+           where user_id = ${userId}
+        `),
+      ) as Array<{
+        group_id: number
+        expires_at: Date | string | null
+        previous_primary_group_id: number | null
+      }>
+
+      const rows = membershipRows.map((row) => ({
+        groupId: Number(row.group_id),
+        expiresAt: row.expires_at === null ? null : new Date(row.expires_at),
+        previousPrimary:
+          row.previous_primary_group_id === null ? null : Number(row.previous_primary_group_id),
+      }))
+
+      const held = Number(user.primary_group_id)
+      const lapsed = rows.find(
+        (row) =>
+          row.groupId === held &&
+          row.previousPrimary !== null &&
+          row.expiresAt !== null &&
+          row.expiresAt.getTime() <= now.getTime(),
+      )
+      const effectivePrimary = lapsed?.previousPrimary ?? held
+      if (effectivePrimary === group.id) return true
+
+      return rows.some(
+        (row) =>
+          row.groupId === group.id &&
+          (row.expiresAt === null || row.expiresAt.getTime() > now.getTime()),
+      )
+    },
   }
 }
 

package/src/plugin-role.ts

@@ -0,0 +1,79 @@
+import { sql } from 'drizzle-orm'
+
+import { pluginTablePrefix } from '@meith/plugin-kit'
+
+import type { Tx } from './permission-version'
+import { resultRows } from './result-rows'
+
+const ROLE_PATTERN = /^plugin_[a-z][a-z0-9_]{1,63}$/
+
+export function pluginDbRole(pluginKey: string): string {
+  const role = `plugin_${pluginKey.replace(/-/g, '_')}`
+  if (!ROLE_PATTERN.test(role)) {
+    throw new Error(`plugin key "${pluginKey}" does not map to a usable database role name.`)
+  }
+  return role
+}
+
+function quoteIdentifier(name: string): string {
+  return `"${name.replace(/"/g, '""')}"`
+}
+
+function quoteLiteral(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`
+}
+
+export async function ensurePluginDataRole(executor: Tx, pluginKey: string): Promise<void> {
+  const role = pluginDbRole(pluginKey)
+  const roleIdent = quoteIdentifier(role)
+  const prefix = pluginTablePrefix(pluginKey)
+
+  await executor.execute(
+    sql.raw(
+      `do $meith$ begin
+         if not exists (select 1 from pg_roles where rolname = ${quoteLiteral(role)}) then
+           create role ${roleIdent} with nologin;
+         end if;
+       exception when duplicate_object then null;
+       end $meith$;`,
+    ),
+  )
+
+  await executor.execute(sql.raw(`grant ${roleIdent} to current_user`))
+  await executor.execute(sql.raw(`grant usage on schema public to ${roleIdent}`))
+
+  const tables = resultRows(
+    await executor.execute(sql`
+      select table_name
+        from information_schema.tables
+       where table_schema = 'public'
+         and table_type = 'BASE TABLE'
+         and table_name like ${`${prefix}%`}
+    `),
+  ) as Array<{ table_name: string }>
+
+  const sequences = resultRows(
+    await executor.execute(sql`
+      select sequence_name
+        from information_schema.sequences
+       where sequence_schema = 'public'
+         and sequence_name like ${`${prefix}%`}
+    `),
+  ) as Array<{ sequence_name: string }>
+
+  for (const { table_name } of tables) {
+    await executor.execute(
+      sql.raw(
+        `grant select, insert, update, delete on ${quoteIdentifier(String(table_name))} to ${roleIdent}`,
+      ),
+    )
+  }
+
+  for (const { sequence_name } of sequences) {
+    await executor.execute(
+      sql.raw(
+        `grant usage, select, update on ${quoteIdentifier(String(sequence_name))} to ${roleIdent}`,
+      ),
+    )
+  }
+}

package/src/post-repo.ts

@@ -176,6 +176,32 @@ export class PostgresPostRepository implements PostRepository {
     return { number, page, afterId: cursor[0]?.id ?? null }
   }
 
+  async locateFirstUnread(
+    threadId: number,
+    after: { readonly postId: number; readonly since: Date | null },
+    options: { readonly scope: ContentScope; readonly pageSize: number },
+  ): Promise<PostLocation | null> {
+    const visible: SQL = visibleIn(posts.visibility, options.scope)
+
+    const target = await this.db
+      .select({ id: posts.id })
+      .from(posts)
+      .where(
+        and(
+          eq(posts.threadId, threadId),
+          visible,
+          gt(posts.id, after.postId),
+          ...(after.since === null ? [] : [gt(posts.createdAt, after.since)]),
+        ),
+      )
+      .orderBy(asc(posts.id))
+      .limit(1)
+
+    const firstId = target[0]?.id
+    if (firstId === undefined) return null
+    return this.locate(threadId, firstId, options)
+  }
+
   async findVisibleById(threadId: number, postId: number): Promise<number | null> {
     const rows = await this.db
       .select({ id: posts.id })