@meith/db 0.16.0

package/src/forum-repo.ts

@@ -0,0 +1,206 @@
+import { asc, eq, sql } from 'drizzle-orm'
+
+import type {
+  ForumListingRow,
+  ForumRepository,
+  ForumRow,
+  ForumType,
+  LastPostSummary,
+  MovePlan,
+  MoveTarget,
+  NewForum,
+} from '@meith/forums'
+import { childPath, planCreate, planMove } from '@meith/forums'
+
+import type { Database } from './client'
+import { forums } from './schema'
+
+const FOREST_LOCK_KEY = 0x0f01_0001
+
+const FORUM_COLUMNS = {
+  id: forums.id,
+  type: forums.type,
+  title: forums.title,
+  slug: forums.slug,
+  description: forums.description,
+  parentId: forums.parentId,
+  path: forums.path,
+  depth: forums.depth,
+  displayOrder: forums.displayOrder,
+  linkUrl: forums.linkUrl,
+} as const
+
+const FORUM_LISTING_COLUMNS = {
+  ...FORUM_COLUMNS,
+  allowThreads: forums.allowThreads,
+  threadCount: forums.threadCount,
+  postCount: forums.postCount,
+  lastPostId: forums.lastPostId,
+  lastPostThreadId: forums.lastPostThreadId,
+  lastPostThreadTitle: forums.lastPostThreadTitle,
+  lastPostUserId: forums.lastPostUserId,
+  lastPostUsername: forums.lastPostUsername,
+  lastPostAt: forums.lastPostAt,
+} as const
+
+type SelectedForum = {
+  [K in keyof typeof FORUM_COLUMNS]: unknown
+}
+
+type SelectedListingForum = {
+  [K in keyof typeof FORUM_LISTING_COLUMNS]: unknown
+}
+
+function toForumRow(row: SelectedForum): ForumRow {
+  return {
+    id: row.id as number,
+    type: row.type as ForumType,
+    title: row.title as string,
+    slug: row.slug as string,
+    description: (row.description ?? null) as string | null,
+    parentId: (row.parentId ?? null) as number | null,
+    path: row.path as string,
+    depth: row.depth as number,
+    displayOrder: row.displayOrder as number,
+    linkUrl: (row.linkUrl ?? null) as string | null,
+  }
+}
+
+function toLastPost(row: SelectedListingForum): LastPostSummary | null {
+  const postId = row.lastPostId as number | null
+  const threadId = row.lastPostThreadId as number | null
+  const at = row.lastPostAt as Date | null
+
+  if (postId === null || threadId === null || at === null) return null
+
+  return {
+    postId,
+    threadId,
+    threadTitle: (row.lastPostThreadTitle ?? '') as string,
+    userId: (row.lastPostUserId ?? null) as number | null,
+    username: (row.lastPostUsername ?? '') as string,
+    at,
+  }
+}
+
+export class PostgresForumRepository implements ForumRepository {
+  constructor(private readonly db: Database) {}
+
+  async listAll(): Promise<ForumRow[]> {
+    const rows = await this.db
+      .select(FORUM_COLUMNS)
+      .from(forums)
+      .orderBy(asc(forums.displayOrder), asc(forums.id))
+    return rows.map(toForumRow)
+  }
+
+  async listListing(): Promise<ForumListingRow[]> {
+    const rows = await this.db
+      .select(FORUM_LISTING_COLUMNS)
+      .from(forums)
+      .orderBy(asc(forums.displayOrder), asc(forums.id))
+
+    return rows.map((row) => ({
+      ...toForumRow(row),
+      allowThreads: row.allowThreads as boolean,
+      threadCount: row.threadCount as number,
+      postCount: row.postCount as number,
+      lastPost: toLastPost(row),
+    }))
+  }
+
+  async findById(id: number): Promise<ForumRow | null> {
+    const rows = await this.db.select(FORUM_COLUMNS).from(forums).where(eq(forums.id, id)).limit(1)
+    const row = rows[0]
+    return row ? toForumRow(row) : null
+  }
+
+  async create(input: NewForum): Promise<ForumRow> {
+    return this.db.transaction(async (tx) => {
+      await tx.execute(sql`select pg_advisory_xact_lock(${FOREST_LOCK_KEY})`)
+
+      const rows = (await tx.select(FORUM_COLUMNS).from(forums)).map(toForumRow)
+      const plan = planCreate(rows, input)
+
+      const inserted = await tx
+        .insert(forums)
+        .values({
+          type: input.type,
+          title: input.title.trim(),
+          slug: input.slug,
+          description: input.description ?? null,
+          parentId: plan.parentId,
+          linkUrl: input.linkUrl ?? null,
+          allowThreads: input.type === 'forum',
+          displayOrder: plan.displayOrder,
+          depth: plan.depth,
+          path: '',
+        })
+        .returning({ id: forums.id })
+
+      const id = inserted[0]?.id
+      if (id === undefined) throw new Error('Forum insert returned no id')
+
+      const path = childPath(plan.parentPath, id)
+      await tx.update(forums).set({ path }).where(eq(forums.id, id))
+
+      const created = await tx.select(FORUM_COLUMNS).from(forums).where(eq(forums.id, id)).limit(1)
+      return toForumRow(created[0] as SelectedForum)
+    })
+  }
+
+  async move(forumId: number, target: MoveTarget): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`select pg_advisory_xact_lock(${FOREST_LOCK_KEY})`)
+
+      const rows = (await tx.select(FORUM_COLUMNS).from(forums).orderBy(asc(forums.id))).map(
+        toForumRow,
+      )
+
+      await this.applyPlanWith(tx, planMove(rows, forumId, target))
+    })
+  }
+
+  async applyMove(plan: MovePlan): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`select pg_advisory_xact_lock(${FOREST_LOCK_KEY})`)
+      await this.applyPlanWith(tx, plan)
+    })
+  }
+
+  private async applyPlanWith(
+    tx: Parameters<Parameters<Database['transaction']>[0]>[0],
+    plan: MovePlan,
+  ): Promise<void> {
+    if (plan.pathUpdates.length > 0) {
+      const values = sql.join(
+        plan.pathUpdates.map((u) => sql`(${u.id}::int, ${u.path}::text, ${u.depth}::int)`),
+        sql`, `,
+      )
+      await tx.execute(sql`
+        update ${forums} as f
+        set path = v.path, depth = v.depth, updated_at = now()
+        from (values ${values}) as v(id, path, depth)
+        where f.id = v.id
+      `)
+    }
+
+    await tx
+      .update(forums)
+      .set({ parentId: plan.newParentId, updatedAt: new Date() })
+      .where(eq(forums.id, plan.forumId))
+
+    if (plan.orderUpdates.length > 0) {
+      const values = sql.join(
+        plan.orderUpdates.map((o) => sql`(${o.id}::int, ${o.displayOrder}::int)`),
+        sql`, `,
+      )
+      await tx.execute(sql`
+        update ${forums} as f
+        set display_order = v.display_order, updated_at = now()
+        from (values ${values}) as v(id, display_order)
+        where f.id = v.id
+      `)
+    }
+  }
+}

package/src/group-admin-repo.ts

@@ -0,0 +1,256 @@
+import { sql } from 'drizzle-orm'
+
+import type { PermissionSet } from '@meith/core'
+import { PERMISSION_FIELDS, ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { Database } from './client'
+import { type Tx, withPermissionVersionBump } from './permission-version'
+import { groupRowToPermissionSet } from './permissions-map'
+import { resultRows } from './result-rows'
+import { columnName } from './schema/permission-columns'
+import { keptDisplayGroupSql } from './staff-groups'
+
+export interface GroupSummaryRow {
+  readonly id: number
+  readonly key: string
+  readonly title: string
+  readonly description: string | null
+  readonly displayOrder: number
+  readonly isSystem: boolean
+  readonly isStaffGroup: boolean
+  readonly pluginGrantable: boolean
+  readonly badgeToken: string | null
+  readonly nameColorLight: string | null
+  readonly nameColorDark: string | null
+  readonly badgeImageLight: string | null
+  readonly badgeImageDark: string | null
+  readonly memberCount: number
+}
+
+export interface GroupIdentityInput {
+  readonly title: string
+  readonly description: string | null
+  readonly displayOrder: number
+  readonly isStaffGroup: boolean
+  readonly pluginGrantable: boolean
+  readonly badgeToken: string | null
+  readonly nameColorLight: string | null
+  readonly nameColorDark: string | null
+}
+
+export interface MembershipChunkResult {
+  readonly moved: number
+  readonly nextCursor: number | null
+}
+
+export class PostgresGroupAdminRepository {
+  constructor(private readonly db: Database) {}
+
+  async list(): Promise<readonly GroupSummaryRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select g.id, g.key, g.title, g.description, g.display_order,
+               g.is_system, g.is_staff_group, g.plugin_grantable, g.badge_token,
+               g.name_color_light, g.name_color_dark,
+               g.badge_image_light, g.badge_image_dark,
+               (select count(*) from users u where u.primary_group_id = g.id)::int
+                 as member_count
+          from usergroups g
+         order by g.display_order, g.id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      key: String(row.key),
+      title: String(row.title),
+      description: row.description === null ? null : String(row.description),
+      displayOrder: Number(row.display_order),
+      isSystem: row.is_system === true,
+      isStaffGroup: row.is_staff_group === true,
+      pluginGrantable: row.plugin_grantable === true,
+      badgeToken: row.badge_token === null ? null : String(row.badge_token),
+      nameColorLight: row.name_color_light === null ? null : String(row.name_color_light),
+      nameColorDark: row.name_color_dark === null ? null : String(row.name_color_dark),
+      badgeImageLight: row.badge_image_light === null ? null : String(row.badge_image_light),
+      badgeImageDark: row.badge_image_dark === null ? null : String(row.badge_image_dark),
+      memberCount: Number(row.member_count),
+    }))
+  }
+
+  async setBadge(
+    groupId: number,
+    scheme: 'light' | 'dark',
+    key: string | null,
+  ): Promise<string | null> {
+    const column = scheme === 'dark' ? sql`badge_image_dark` : sql`badge_image_light`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update usergroups u
+           set ${column} = ${key}, updated_at = now()
+          from usergroups old
+         where u.id = ${groupId}
+           and old.id = u.id
+        returning old.${column} as previous
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const previous = rows[0]?.previous
+    return typeof previous === 'string' ? previous : null
+  }
+
+  async readPermissions(groupId: number): Promise<PermissionSet | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`select * from usergroups where id = ${groupId}`),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    return row === undefined ? null : groupRowToPermissionSet(camelise(row))
+  }
+
+  async updateIdentity(groupId: number, input: GroupIdentityInput): Promise<void> {
+    await this.withVersionBump(async (tx) => {
+      await tx.execute(sql`
+        update usergroups
+           set title = ${input.title},
+               description = ${input.description},
+               display_order = ${input.displayOrder},
+               is_staff_group = ${input.isStaffGroup},
+               plugin_grantable = ${input.pluginGrantable},
+               badge_token = ${input.badgeToken},
+               name_color_light = ${input.nameColorLight},
+               name_color_dark = ${input.nameColorDark},
+               updated_at = now()
+         where id = ${groupId}
+      `)
+    })
+  }
+
+  async savePermissions(
+    groupId: number,
+    permissions: Readonly<Record<string, boolean | number>>,
+  ): Promise<void> {
+    const assignments = PERMISSION_FIELDS.map(
+      (field) =>
+        sql`${sql.raw(columnName(field.key))} = ${permissions[field.key] ?? field.fallback}`,
+    )
+
+    await this.withVersionBump(async (tx) => {
+      await tx.execute(sql`
+        update usergroups
+           set ${sql.join(assignments, sql`, `)}, updated_at = now()
+         where id = ${groupId}
+      `)
+    })
+  }
+
+  async create(input: {
+    readonly key: string
+    readonly title: string
+    readonly copyFromGroupId: number
+  }): Promise<number> {
+    const columns = PERMISSION_FIELDS.map((field) => sql.raw(columnName(field.key)))
+
+    return this.withVersionBump(async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`
+          insert into usergroups (key, title, is_system, ${sql.join(columns, sql`, `)})
+          select ${input.key}, ${input.title}, false,
+                 ${sql.join(
+                   PERMISSION_FIELDS.map((field) => sql.raw(columnName(field.key))),
+                   sql`, `,
+                 )}
+            from usergroups where id = ${input.copyFromGroupId}
+          returning id
+        `),
+      ) as Array<{ id: number }>
+
+      const id = rows[0]?.id
+      if (id === undefined) {
+        throw new ValidationError(msg('error.db.there-group-copy-from'))
+      }
+      return Number(id)
+    })
+  }
+
+  async remove(groupId: number, moveMembersTo: number): Promise<void> {
+    if (groupId === moveMembersTo) {
+      throw new ValidationError(msg('error.db.members-moved-into-group-being'))
+    }
+
+    await this.withVersionBump(async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`select is_system from usergroups where id = ${groupId}`),
+      ) as Array<{ is_system: boolean }>
+
+      if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-group'))
+      if (rows[0].is_system === true) {
+        throw new ValidationError(msg('error.db.group-part-how-board-works'))
+      }
+
+      await tx.execute(sql`
+        update users
+           set primary_group_id = ${moveMembersTo},
+               display_group_id = ${keptDisplayGroupSql({
+                 column: sql.raw('display_group_id'),
+                 leavingGroupId: sql`${groupId}`,
+                 arrivingGroupId: sql`${moveMembersTo}`,
+               })}
+         where primary_group_id = ${groupId}
+      `)
+      await tx.execute(sql`delete from usergroups where id = ${groupId}`)
+    })
+  }
+
+  async moveMembersChunk(input: {
+    readonly fromGroupId: number
+    readonly toGroupId: number
+    readonly afterUserId: number
+    readonly limit: number
+  }): Promise<MembershipChunkResult> {
+    if (input.fromGroupId === input.toGroupId) {
+      throw new ValidationError(msg('error.db.choose-two-different-groups'))
+    }
+
+    return this.withVersionBump(async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`
+          update users
+             set primary_group_id = ${input.toGroupId},
+                 display_group_id = ${keptDisplayGroupSql({
+                   column: sql.raw('display_group_id'),
+                   leavingGroupId: sql`${input.fromGroupId}`,
+                   arrivingGroupId: sql`${input.toGroupId}`,
+                 })}
+           where id in (
+             select id from users
+              where primary_group_id = ${input.fromGroupId} and id > ${input.afterUserId}
+              order by id
+              limit ${input.limit}
+           )
+          returning id
+        `),
+      ) as Array<{ id: number }>
+
+      const ids = rows.map((row) => Number(row.id)).sort((a, b) => a - b)
+      return {
+        moved: ids.length,
+        nextCursor: ids.length < input.limit ? null : (ids.at(-1) ?? null),
+      }
+    })
+  }
+
+  private async withVersionBump<T>(work: (tx: Tx) => Promise<T>): Promise<T> {
+    return withPermissionVersionBump(this.db, work)
+  }
+}
+
+function camelise(row: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(row)) {
+    out[key.replace(/_([a-z])/g, (_match, letter: string) => letter.toUpperCase())] = value
+  }
+  return out
+}

package/src/group-identity-repo.ts

@@ -0,0 +1,84 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { displayGroupIdSql } from './staff-groups'
+
+export interface GroupIdentity {
+  readonly groupId: number
+  readonly title: string
+  readonly nameColorLight: string | null
+  readonly nameColorDark: string | null
+  readonly badgeImageLight: string | null
+  readonly badgeImageDark: string | null
+}
+
+export interface MemberStanding extends GroupIdentity {
+  readonly reputation: number
+}
+
+export class PostgresGroupIdentityRepository {
+  constructor(private readonly db: Database) {}
+
+  async forUsers(userIds: readonly number[]): Promise<ReadonlyMap<number, MemberStanding>> {
+    if (userIds.length === 0) return new Map()
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select u.id as user_id,
+               u.reputation,
+               g.id as group_id,
+               g.title,
+               g.name_color_light,
+               g.name_color_dark,
+               g.badge_image_light,
+               g.badge_image_dark
+          from users u
+          join usergroups p
+            on p.id = u.primary_group_id
+          join usergroups g
+            on g.id = ${displayGroupIdSql('u', 'p')}
+         where u.id in ${sql`(${sql.join(
+           userIds.map((id) => sql`${id}`),
+           sql`, `,
+         )})`}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return new Map(
+      rows.map((row) => [
+        Number(row.user_id),
+        {
+          groupId: Number(row.group_id),
+          title: String(row.title),
+          nameColorLight: row.name_color_light === null ? null : String(row.name_color_light),
+          nameColorDark: row.name_color_dark === null ? null : String(row.name_color_dark),
+          badgeImageLight: row.badge_image_light === null ? null : String(row.badge_image_light),
+          badgeImageDark: row.badge_image_dark === null ? null : String(row.badge_image_dark),
+          reputation: Number(row.reputation ?? 0),
+        },
+      ]),
+    )
+  }
+
+  async styled(): Promise<readonly GroupIdentity[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id as group_id, title, name_color_light, name_color_dark,
+               badge_image_light, badge_image_dark
+          from usergroups
+         where name_color_light is not null or name_color_dark is not null
+         order by display_order, id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      groupId: Number(row.group_id),
+      title: String(row.title),
+      nameColorLight: row.name_color_light === null ? null : String(row.name_color_light),
+      nameColorDark: row.name_color_dark === null ? null : String(row.name_color_dark),
+      badgeImageLight: row.badge_image_light === null ? null : String(row.badge_image_light),
+      badgeImageDark: row.badge_image_dark === null ? null : String(row.badge_image_dark),
+    }))
+  }
+}

package/src/identity-link-repo.ts

@@ -0,0 +1,145 @@
+import { and, asc, eq } from 'drizzle-orm'
+
+import type {
+  LinkIdentityInput,
+  NewPasskey,
+  PasskeyRecord,
+  PasskeyRepository,
+  UserIdentityRecord,
+  UserIdentityRepository,
+} from '@meith/accounts'
+
+import type { Database } from './client'
+import { passkeys, userIdentities } from './schema'
+
+const IDENTITY_COLUMNS = {
+  id: userIdentities.id,
+  userId: userIdentities.userId,
+  provider: userIdentities.provider,
+  subject: userIdentities.subject,
+  label: userIdentities.label,
+  linkedAt: userIdentities.linkedAt,
+  lastUsedAt: userIdentities.lastUsedAt,
+} as const
+
+export class PostgresUserIdentityRepository implements UserIdentityRepository {
+  constructor(private readonly db: Database) {}
+
+  async findBySubject(provider: string, subject: string): Promise<UserIdentityRecord | null> {
+    const rows = await this.db
+      .select(IDENTITY_COLUMNS)
+      .from(userIdentities)
+      .where(and(eq(userIdentities.provider, provider), eq(userIdentities.subject, subject)))
+      .limit(1)
+    return rows[0] ?? null
+  }
+
+  async listForUser(userId: number): Promise<readonly UserIdentityRecord[]> {
+    return this.db
+      .select(IDENTITY_COLUMNS)
+      .from(userIdentities)
+      .where(eq(userIdentities.userId, userId))
+      .orderBy(asc(userIdentities.id))
+  }
+
+  async link(input: LinkIdentityInput): Promise<UserIdentityRecord> {
+    const inserted = await this.db
+      .insert(userIdentities)
+      .values({
+        userId: input.userId,
+        provider: input.provider,
+        subject: input.subject,
+        label: input.label,
+        linkedAt: input.now,
+      })
+      .onConflictDoNothing({
+        target: [userIdentities.provider, userIdentities.subject],
+      })
+      .returning(IDENTITY_COLUMNS)
+
+    const record = inserted[0] ?? (await this.findBySubject(input.provider, input.subject))
+    if (record === null || record === undefined) {
+      throw new Error('the linked identity vanished between insert and read')
+    }
+    return record
+  }
+
+  async unlink(userId: number, identityId: number): Promise<boolean> {
+    const removed = await this.db
+      .delete(userIdentities)
+      .where(and(eq(userIdentities.id, identityId), eq(userIdentities.userId, userId)))
+      .returning({ id: userIdentities.id })
+    return removed.length > 0
+  }
+
+  async markUsed(identityId: number, now: Date): Promise<void> {
+    await this.db
+      .update(userIdentities)
+      .set({ lastUsedAt: now })
+      .where(eq(userIdentities.id, identityId))
+  }
+}
+
+const PASSKEY_COLUMNS = {
+  id: passkeys.id,
+  userId: passkeys.userId,
+  credentialId: passkeys.credentialId,
+  publicKey: passkeys.publicKey,
+  signCount: passkeys.signCount,
+  label: passkeys.label,
+  transports: passkeys.transports,
+  createdAt: passkeys.createdAt,
+  lastUsedAt: passkeys.lastUsedAt,
+} as const
+
+export class PostgresPasskeyRepository implements PasskeyRepository {
+  constructor(private readonly db: Database) {}
+
+  async findByCredentialId(credentialId: string): Promise<PasskeyRecord | null> {
+    const rows = await this.db
+      .select(PASSKEY_COLUMNS)
+      .from(passkeys)
+      .where(eq(passkeys.credentialId, credentialId))
+      .limit(1)
+    return rows[0] ?? null
+  }
+
+  async listForUser(userId: number): Promise<readonly PasskeyRecord[]> {
+    return this.db
+      .select(PASSKEY_COLUMNS)
+      .from(passkeys)
+      .where(eq(passkeys.userId, userId))
+      .orderBy(asc(passkeys.id))
+  }
+
+  async create(input: NewPasskey): Promise<PasskeyRecord> {
+    const rows = await this.db
+      .insert(passkeys)
+      .values({
+        userId: input.userId,
+        credentialId: input.credentialId,
+        publicKey: input.publicKey,
+        signCount: input.signCount,
+        label: input.label,
+        transports: input.transports,
+        createdAt: input.now,
+      })
+      .returning(PASSKEY_COLUMNS)
+    return rows[0]!
+  }
+
+  async remove(userId: number, passkeyId: number): Promise<boolean> {
+    const removed = await this.db
+      .delete(passkeys)
+      .where(and(eq(passkeys.id, passkeyId), eq(passkeys.userId, userId)))
+      .returning({ id: passkeys.id })
+    return removed.length > 0
+  }
+
+  async markUsed(passkeyId: number, signCount: number, now: Date): Promise<void> {
+    await this.db
+      .update(passkeys)
+      .set({ signCount, lastUsedAt: now })
+      .where(eq(passkeys.id, passkeyId))
+  }
+}