@meith/db 0.16.0

package/src/attachment-repo.ts

@@ -0,0 +1,240 @@
+import { sql } from 'drizzle-orm'
+
+import type {
+  AttachmentForDownload,
+  AttachmentRecord,
+  AttachmentRepository,
+  AttachmentStatus,
+  CreateAttachmentInput,
+  ReadyInput,
+} from '@meith/attachments'
+
+import type { Database } from './client'
+import { forgetOrphanKeys, rememberOrphanKey } from './orphan-keys'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+
+interface RawAttachment {
+  id: number
+  post_id: number | null
+  forum_id: number
+  uploader_user_id: number | null
+  filename: string
+  content_type: string
+  size_bytes: number
+  storage_key: string | null
+  source_key: string | null
+  thumbnail_key: string | null
+  width: number | null
+  height: number | null
+  status: string
+  failure_reason: string | null
+  download_count: number
+  created_at: string | Date
+}
+
+const COLUMNS = sql`
+  id, post_id, forum_id, uploader_user_id, filename, content_type, size_bytes,
+  storage_key, source_key, thumbnail_key, width, height, status,
+  failure_reason, download_count, created_at
+`
+
+function toRecord(row: RawAttachment): AttachmentRecord {
+  return {
+    id: Number(row.id),
+    postId: row.post_id === null ? null : Number(row.post_id),
+    forumId: Number(row.forum_id),
+    uploaderUserId: row.uploader_user_id === null ? null : Number(row.uploader_user_id),
+    filename: row.filename,
+    contentType: row.content_type,
+    sizeBytes: Number(row.size_bytes),
+    storageKey: row.storage_key,
+    sourceKey: row.source_key,
+    thumbnailKey: row.thumbnail_key,
+    width: row.width === null ? null : Number(row.width),
+    height: row.height === null ? null : Number(row.height),
+    status: (['pending', 'ready', 'failed'] as const).includes(row.status as AttachmentStatus)
+      ? (row.status as AttachmentStatus)
+      : 'failed',
+    failureReason: row.failure_reason,
+    downloadCount: Number(row.download_count),
+    createdAt: toDate(row.created_at),
+  }
+}
+
+export class PostgresAttachmentRepository implements AttachmentRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(input: CreateAttachmentInput): Promise<AttachmentRecord> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into attachments
+               (post_id, forum_id, uploader_user_id, filename, content_type,
+                size_bytes, storage_key, source_key, status, ready_at)
+        values (${input.postId}, ${input.forumId}, ${input.uploaderUserId},
+                ${input.filename}, ${input.contentType}, ${input.sizeBytes},
+                ${input.storageKey}, ${input.sourceKey}, ${input.status},
+                ${input.status === 'ready' ? sql`now()` : sql`null`})
+        returning ${COLUMNS}
+      `),
+    ) as RawAttachment[]
+
+    if (rows[0] === undefined) throw new Error('Attachment insert returned no row')
+    return toRecord(rows[0])
+  }
+
+  async findById(id: number): Promise<AttachmentRecord | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`select ${COLUMNS} from attachments where id = ${id}`),
+    ) as RawAttachment[]
+    return rows[0] === undefined ? null : toRecord(rows[0])
+  }
+
+  async findForDownload(id: number): Promise<AttachmentForDownload | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select a.id, a.post_id, a.forum_id, a.uploader_user_id, a.filename,
+               a.content_type, a.size_bytes, a.storage_key, a.source_key,
+               a.thumbnail_key, a.width, a.height, a.status, a.failure_reason,
+               a.download_count, a.created_at,
+               p.visibility as post_visibility, t.visibility as thread_visibility,
+               t.author_user_id as thread_author_user_id
+          from attachments a
+          join posts p on p.id = a.post_id
+          join threads t on t.id = p.thread_id
+         where a.id = ${id}
+      `),
+    ) as Array<
+      RawAttachment & {
+        post_visibility: string
+        thread_visibility: string
+        thread_author_user_id: number | null
+      }
+    >
+
+    const row = rows[0]
+    if (row === undefined) return null
+    return {
+      record: toRecord(row),
+      postVisibility: row.post_visibility,
+      threadVisibility: row.thread_visibility,
+      threadAuthorUserId:
+        row.thread_author_user_id === null ? null : Number(row.thread_author_user_id),
+    }
+  }
+
+  async listForPosts(postIds: readonly number[]): Promise<readonly AttachmentRecord[]> {
+    if (postIds.length === 0) return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select ${COLUMNS} from attachments
+         where post_id in ${sql`(${sql.join(
+           postIds.map((id) => sql`${id}`),
+           sql`, `,
+         )})`}
+         order by post_id, id
+      `),
+    ) as RawAttachment[]
+
+    return rows.map(toRecord)
+  }
+
+  async countForPost(postId: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(
+        sql`select count(*)::int as n from attachments where post_id = ${postId}`,
+      ),
+    ) as Array<{ n: number }>
+    return Number(rows[0]?.n ?? 0)
+  }
+
+  async markReady(id: number, input: ReadyInput): Promise<void> {
+    await this.db.execute(sql`
+      update attachments
+         set storage_key = ${input.storageKey},
+             thumbnail_key = ${input.thumbnailKey},
+             width = ${input.width},
+             height = ${input.height},
+             size_bytes = ${input.sizeBytes},
+             source_key = null,
+             status = 'ready',
+             ready_at = now()
+       where id = ${id} and status = 'pending'
+    `)
+  }
+
+  async markFailed(id: number, reason: string): Promise<void> {
+    await this.db.execute(sql`
+      update attachments
+         set status = 'failed', failure_reason = ${reason}, source_key = null
+       where id = ${id} and status = 'pending'
+    `)
+  }
+
+  async recordDownload(id: number): Promise<void> {
+    await this.db.execute(sql`
+      update attachments set download_count = download_count + 1 where id = ${id}
+    `)
+  }
+
+  async attachTo(id: number, postId: number): Promise<AttachmentRecord | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update attachments
+           set post_id = ${postId}
+         where id = ${id} and post_id is null
+        returning ${COLUMNS}
+      `),
+    ) as RawAttachment[]
+    return rows[0] === undefined ? null : toRecord(rows[0])
+  }
+
+  async deleteOrphans(before: Date, limit: number): Promise<readonly AttachmentRecord[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from attachments
+         where id in (
+           select id from attachments
+            where post_id is null and created_at < ${before}
+            order by created_at
+            limit ${limit}
+         )
+        returning ${COLUMNS}
+      `),
+    ) as RawAttachment[]
+    return rows.map(toRecord)
+  }
+
+  async stalled(before: Date, limit: number): Promise<readonly AttachmentRecord[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select ${COLUMNS} from attachments
+         where status = 'pending' and created_at < ${before}
+         order by created_at
+         limit ${limit}
+      `),
+    ) as RawAttachment[]
+    return rows.map(toRecord)
+  }
+
+  async rememberKey(key: string): Promise<void> {
+    await rememberOrphanKey(this.db, key)
+  }
+
+  async forgetKeys(keys: readonly string[]): Promise<void> {
+    await forgetOrphanKeys(this.db, keys)
+  }
+
+  async staleKeys(before: Date, limit: number): Promise<readonly string[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select storage_key from attachment_orphans
+         where created_at < ${before}
+         order by created_at
+         limit ${limit}
+      `),
+    ) as Array<{ storage_key: string }>
+    return rows.map((row) => row.storage_key)
+  }
+}

package/src/authorization-source.ts

@@ -0,0 +1,138 @@
+import { and, inArray, sql } from 'drizzle-orm'
+
+import type {
+  AuthorizationSource,
+  ForumOverride,
+  GroupDefaults,
+  ModeratorAppointment,
+} from '@meith/authorization'
+
+import type { Database } from './client'
+import { forumRowToOverride, groupRowToPermissionSet } from './permissions-map'
+import { resultRows } from './result-rows'
+import { forumPermissions, forums, usergroups } from './schema'
+
+export function parseAncestorPath(path: string): number[] {
+  const ids = path
+    .split('.')
+    .map((segment) => Number(segment))
+    .filter((n) => Number.isInteger(n) && n > 0)
+  ids.reverse()
+  return ids
+}
+
+export class PostgresAuthorizationSource implements AuthorizationSource {
+  constructor(private readonly db: Database) {}
+
+  async groupDefaults(groupIds: readonly number[]): Promise<readonly GroupDefaults[]> {
+    if (groupIds.length === 0) return []
+
+    const rows = await this.db
+      .select()
+      .from(usergroups)
+      .where(inArray(usergroups.id, [...groupIds]))
+
+    return rows.map((row) => ({
+      groupId: row.id,
+      permissions: groupRowToPermissionSet(row as Record<string, unknown>),
+    }))
+  }
+
+  async ancestorChain(forumId: number): Promise<readonly number[]> {
+    const rows = await this.db
+      .select({ path: forums.path })
+      .from(forums)
+      .where(inArray(forums.id, [forumId]))
+      .limit(1)
+
+    const row = rows[0]
+    if (!row) return []
+    return parseAncestorPath(row.path)
+  }
+
+  async forumOverrides(
+    forumIds: readonly number[],
+    groupIds: readonly number[],
+  ): Promise<readonly ForumOverride[]> {
+    if (forumIds.length === 0 || groupIds.length === 0) return []
+
+    const rows = await this.db
+      .select()
+      .from(forumPermissions)
+      .where(
+        and(
+          inArray(forumPermissions.forumId, [...forumIds]),
+          inArray(forumPermissions.groupId, [...groupIds]),
+        ),
+      )
+
+    return rows.map((row) => ({
+      forumId: row.forumId,
+      groupId: row.groupId,
+      overrides: forumRowToOverride(row as Record<string, unknown>),
+    }))
+  }
+
+  async allForumIds(): Promise<readonly number[]> {
+    const rows = await this.db.select({ id: forums.id }).from(forums)
+    return rows.map((r) => r.id)
+  }
+
+  async allAncestorChains(): Promise<ReadonlyMap<number, readonly number[]>> {
+    const rows = await this.db.select({ id: forums.id, path: forums.path }).from(forums)
+
+    return new Map(rows.map((r) => [r.id, parseAncestorPath(r.path)]))
+  }
+  async moderatorAppointments(
+    userId: number | null,
+    groupIds: readonly number[],
+  ): Promise<readonly ModeratorAppointment[]> {
+    if (userId === null && groupIds.length === 0) return []
+
+    const groupList =
+      groupIds.length === 0
+        ? sql`(null)`
+        : sql`(${sql.join(
+            groupIds.map((id) => sql`${id}`),
+            sql`, `,
+          )})`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select forum_id, cascade_to_subforums, can_approve_content,
+               can_edit_posts, can_soft_delete_posts, can_restore_posts,
+               can_open_close_threads, can_stick_threads, can_move_threads,
+               can_merge_threads, can_split_threads
+          from forum_moderators
+         where (user_id is not null and user_id = ${userId})
+            or (group_id is not null and group_id in ${groupList})
+      `),
+    ) as Array<{
+      forum_id: number
+      cascade_to_subforums: boolean
+      can_approve_content: boolean
+      can_edit_posts: boolean
+      can_soft_delete_posts: boolean
+      can_restore_posts: boolean
+      can_open_close_threads: boolean
+      can_stick_threads: boolean
+      can_move_threads: boolean
+      can_merge_threads: boolean
+      can_split_threads: boolean
+    }>
+
+    return rows.map((row) => ({
+      forumId: Number(row.forum_id),
+      cascadeToSubforums: row.cascade_to_subforums,
+      canApproveContent: row.can_approve_content,
+      canEditPosts: row.can_edit_posts,
+      canSoftDeletePosts: row.can_soft_delete_posts,
+      canRestorePosts: row.can_restore_posts,
+      canOpenCloseThreads: row.can_open_close_threads,
+      canStickThreads: row.can_stick_threads,
+      canMoveThreads: row.can_move_threads,
+      canMergeThreads: row.can_merge_threads,
+      canSplitThreads: row.can_split_threads,
+    }))
+  }
+}

package/src/avatar-repo.ts

@@ -0,0 +1,185 @@
+import { sql } from 'drizzle-orm'
+
+import type { AvatarRepository, AvatarStatus, StoredAvatar } from '@meith/avatars'
+
+import type { Database } from './client'
+import { forgetOrphanKeys, rememberOrphanKey } from './orphan-keys'
+import { resultRows } from './result-rows'
+import { toNullableDate } from './row-values'
+
+interface RawAvatar {
+  id?: number
+  avatar_status: string
+  avatar_key: string | null
+  avatar_source_key: string | null
+  avatar_width: number | null
+  avatar_height: number | null
+  avatar_failure_reason: string | null
+  avatar_updated_at: string | Date | null
+  avatar_locked: boolean
+  avatar_locked_reason: string | null
+}
+
+const STATUSES = ['none', 'pending', 'ready', 'failed'] as const
+
+function toAvatar(row: RawAvatar): StoredAvatar {
+  return {
+    status: STATUSES.includes(row.avatar_status as AvatarStatus)
+      ? (row.avatar_status as AvatarStatus)
+      : 'failed',
+    key: row.avatar_key,
+    sourceKey: row.avatar_source_key,
+    width: row.avatar_width === null ? null : Number(row.avatar_width),
+    height: row.avatar_height === null ? null : Number(row.avatar_height),
+    failureReason: row.avatar_failure_reason,
+    updatedAt: toNullableDate(row.avatar_updated_at),
+    locked: row.avatar_locked === true,
+    lockedReason: row.avatar_locked_reason,
+  }
+}
+
+const COLUMNS = sql`
+  avatar_status, avatar_key, avatar_source_key, avatar_width, avatar_height,
+  avatar_failure_reason, avatar_updated_at, avatar_locked, avatar_locked_reason
+`
+
+function droppedKeys(row: { avatar_key: string | null; avatar_source_key: string | null }) {
+  return [row.avatar_key, row.avatar_source_key].filter((key): key is string => key !== null)
+}
+
+export class PostgresAvatarRepository implements AvatarRepository {
+  constructor(private readonly db: Database) {}
+
+  async find(userId: number): Promise<StoredAvatar | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`select ${COLUMNS} from users where id = ${userId}`),
+    ) as RawAvatar[]
+    return rows[0] === undefined ? null : toAvatar(rows[0])
+  }
+
+  async readMany(userIds: readonly number[]): Promise<ReadonlyMap<number, StoredAvatar>> {
+    if (userIds.length === 0) return new Map()
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, ${COLUMNS} from users
+         where id in ${sql`(${sql.join(
+           userIds.map((id) => sql`${id}`),
+           sql`, `,
+         )})`}
+      `),
+    ) as RawAvatar[]
+
+    return new Map(rows.map((row) => [Number(row.id), toAvatar(row)]))
+  }
+
+  async beginUpload(input: {
+    readonly userId: number
+    readonly sourceKey: string
+    readonly at: Date
+  }): Promise<{ replaced: readonly string[] }> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update users u
+           set avatar_source_key = ${input.sourceKey},
+               avatar_key = null,
+               avatar_status = 'pending',
+               avatar_failure_reason = null,
+               avatar_width = null,
+               avatar_height = null,
+               avatar_updated_at = ${input.at}
+          from users old
+         where u.id = ${input.userId}
+           and old.id = u.id
+           and u.avatar_locked = false
+        returning old.avatar_key, old.avatar_source_key
+      `),
+    ) as Array<{ avatar_key: string | null; avatar_source_key: string | null }>
+
+    const row = rows[0]
+    if (row === undefined) return { replaced: [input.sourceKey] }
+    return { replaced: droppedKeys(row) }
+  }
+
+  async markReady(input: {
+    readonly userId: number
+    readonly key: string
+    readonly width: number
+    readonly height: number
+  }): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set avatar_key = ${input.key},
+             avatar_source_key = null,
+             avatar_width = ${input.width},
+             avatar_height = ${input.height},
+             avatar_status = 'ready'
+       where id = ${input.userId} and avatar_status = 'pending'
+    `)
+  }
+
+  async markFailed(userId: number, reason: string): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set avatar_status = 'failed',
+             avatar_failure_reason = ${reason},
+             avatar_source_key = null
+       where id = ${userId} and avatar_status = 'pending'
+    `)
+  }
+
+  async clear(userId: number): Promise<{ replaced: readonly string[] }> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update users u
+           set avatar_key = null,
+               avatar_source_key = null,
+               avatar_status = 'none',
+               avatar_failure_reason = null,
+               avatar_width = null,
+               avatar_height = null,
+               avatar_updated_at = null
+          from users old
+         where u.id = ${userId}
+           and old.id = u.id
+           and u.avatar_locked = false
+        returning old.avatar_key, old.avatar_source_key
+      `),
+    ) as Array<{ avatar_key: string | null; avatar_source_key: string | null }>
+
+    const row = rows[0]
+    return { replaced: row === undefined ? [] : droppedKeys(row) }
+  }
+
+  async lock(input: {
+    readonly userId: number
+    readonly locked: boolean
+    readonly reason: string | null
+  }): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set avatar_locked = ${input.locked}, avatar_locked_reason = ${input.reason}
+       where id = ${input.userId}
+    `)
+  }
+
+  async stalled(before: Date, limit: number): Promise<readonly number[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id from users
+         where avatar_status = 'pending' and avatar_updated_at < ${before}
+         order by avatar_updated_at
+         limit ${limit}
+      `),
+    ) as Array<{ id: number }>
+    return rows.map((row) => Number(row.id))
+  }
+
+  async rememberKey(key: string): Promise<void> {
+    await rememberOrphanKey(this.db, key)
+  }
+
+  async forgetKeys(keys: readonly string[]): Promise<void> {
+    await forgetOrphanKeys(this.db, keys)
+  }
+}

package/src/ban-repos.ts

@@ -0,0 +1,146 @@
+import { and, asc, eq, isNotNull, isNull, lte, sql } from 'drizzle-orm'
+
+import type {
+  BanFilter,
+  BanFilterRepository,
+  BanFilterType,
+  BanRecord,
+  BanRepository,
+  CreateBanInput,
+} from '@meith/accounts'
+
+import type { Database } from './client'
+import { banFilters, bans, rememberTokens, sessions, users } from './schema'
+
+const BAN_COLUMNS = {
+  id: bans.id,
+  userId: bans.userId,
+  reason: bans.reason,
+  publicReason: bans.publicReason,
+  previousPrimaryGroupId: bans.previousPrimaryGroupId,
+  expiresAt: bans.expiresAt,
+  liftedAt: bans.liftedAt,
+} as const
+
+type Tx = Parameters<Parameters<Database['transaction']>[0]>[0]
+
+async function liftWithin(tx: Tx, ban: BanRecord, now: Date): Promise<void> {
+  await tx.update(bans).set({ liftedAt: now }).where(eq(bans.id, ban.id))
+
+  if (ban.previousPrimaryGroupId !== null) {
+    await tx
+      .update(users)
+      .set({
+        primaryGroupId: ban.previousPrimaryGroupId,
+        displayGroupId: ban.previousPrimaryGroupId,
+      })
+      .where(eq(users.id, ban.userId))
+  }
+}
+
+export class PostgresBanRepository implements BanRepository {
+  constructor(private readonly db: Database) {}
+
+  async findActive(userId: number): Promise<BanRecord | null> {
+    const rows = await this.db
+      .select(BAN_COLUMNS)
+      .from(bans)
+      .where(and(eq(bans.userId, userId), isNull(bans.liftedAt)))
+      .limit(1)
+
+    return rows[0] ?? null
+  }
+
+  async create(input: CreateBanInput): Promise<BanRecord> {
+    return this.db.transaction(async (tx) => {
+      const [target] = await tx
+        .select({
+          primaryGroupId: users.primaryGroupId,
+        })
+        .from(users)
+        .where(eq(users.id, input.userId))
+        .limit(1)
+
+      if (!target) throw new Error(`Cannot ban unknown user ${input.userId}`)
+
+      const [row] = await tx
+        .insert(bans)
+        .values({
+          userId: input.userId,
+          bannedByUserId: input.bannedByUserId,
+          reason: input.reason,
+          publicReason: input.publicReason,
+          previousPrimaryGroupId: target.primaryGroupId,
+          expiresAt: input.expiresAt,
+          createdAt: input.now,
+        })
+        .returning(BAN_COLUMNS)
+
+      await tx
+        .update(users)
+        .set({ primaryGroupId: input.bannedGroupId, displayGroupId: input.bannedGroupId })
+        .where(eq(users.id, input.userId))
+
+      await tx
+        .update(sessions)
+        .set({ revokedAt: input.now })
+        .where(and(eq(sessions.userId, input.userId), isNull(sessions.revokedAt)))
+
+      await tx
+        .update(rememberTokens)
+        .set({ revokedAt: input.now, revokedReason: 'account_banned' })
+        .where(and(eq(rememberTokens.userId, input.userId), isNull(rememberTokens.revokedAt)))
+
+      return row as BanRecord
+    })
+  }
+
+  async lift(banId: number, now: Date): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      const [ban] = await tx
+        .select(BAN_COLUMNS)
+        .from(bans)
+        .where(and(eq(bans.id, banId), isNull(bans.liftedAt)))
+        .limit(1)
+
+      if (!ban) return
+      await liftWithin(tx, ban, now)
+    })
+  }
+
+  async expireDue(now: Date, limit: number): Promise<number> {
+    return this.db.transaction(async (tx) => {
+      const due = await tx
+        .select(BAN_COLUMNS)
+        .from(bans)
+        .where(and(isNull(bans.liftedAt), isNotNull(bans.expiresAt), lte(bans.expiresAt, now)))
+        .orderBy(asc(bans.expiresAt))
+        .limit(limit)
+        .for('update', { skipLocked: true })
+
+      for (const ban of due) await liftWithin(tx, ban, now)
+
+      if (due.length > 0) {
+        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()
+        `)
+      }
+
+      return due.length
+    })
+  }
+}
+
+export class PostgresBanFilterRepository implements BanFilterRepository {
+  constructor(private readonly db: Database) {}
+
+  async listAll(): Promise<readonly BanFilter[]> {
+    const rows = await this.db
+      .select({ id: banFilters.id, type: banFilters.type, pattern: banFilters.pattern })
+      .from(banFilters)
+
+    return rows.map((r) => ({ id: r.id, type: r.type as BanFilterType, pattern: r.pattern }))
+  }
+}