@meith/db 0.16.0

package/src/navigation-repo.ts

@@ -0,0 +1,288 @@
+import { type SQL, sql } from 'drizzle-orm'
+
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { NAVIGATION_AUDIENCES } from './schema/platform'
+import { idList } from './sql-lists'
+
+export type NavigationAudience = (typeof NAVIGATION_AUDIENCES)[number]
+
+export interface NavigationDropTarget {
+  readonly parentId: number | null
+  readonly afterId: number | null
+}
+
+export interface NavigationItemRow {
+  readonly id: number
+  readonly key: string | null
+  readonly parentId: number | null
+  readonly label: string
+  readonly href: string
+  readonly displayOrder: number
+  readonly audience: NavigationAudience
+  readonly newTab: boolean
+  readonly enabled: boolean
+  readonly visibleToGroups: readonly number[]
+}
+
+/** A navigation item a plugin declares, already namespaced by the host. */
+export interface PluginNavigationRow {
+  readonly key: string
+  readonly href: string
+  readonly audience: NavigationAudience
+  /** The key of the sibling row this one is created under, if any. */
+  readonly parentKey: string | null
+}
+
+export interface NavigationItemInput {
+  readonly parentId: number | null
+  readonly label: string
+  readonly href: string
+  readonly audience: NavigationAudience
+  readonly newTab: boolean
+  readonly enabled: boolean
+  readonly visibleToGroups: readonly number[]
+}
+
+function audienceOf(value: unknown): NavigationAudience {
+  const text = String(value)
+  const found = NAVIGATION_AUDIENCES.find((audience) => audience === text)
+  return found ?? 'all'
+}
+
+function groupsOf(value: unknown): readonly number[] {
+  if (!Array.isArray(value)) return []
+  return value.map((entry) => Number(entry)).filter((id) => Number.isSafeInteger(id))
+}
+
+function toRow(row: Record<string, unknown>): NavigationItemRow {
+  return {
+    id: Number(row.id),
+    key: row.key === null || row.key === undefined ? null : String(row.key),
+    parentId: row.parent_id === null || row.parent_id === undefined ? null : Number(row.parent_id),
+    label: String(row.label),
+    href: String(row.href),
+    displayOrder: Number(row.display_order),
+    audience: audienceOf(row.audience),
+    newTab: row.new_tab === true,
+    enabled: row.enabled === true,
+    visibleToGroups: groupsOf(row.group_ids),
+  }
+}
+
+export class PostgresNavigationRepository {
+  constructor(private readonly db: Database) {}
+
+  async list(): Promise<readonly NavigationItemRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select n.id, n.key, n.parent_id, n.label, n.href, n.display_order, n.audience,
+               n.new_tab, n.enabled,
+               coalesce(
+                 (select array_agg(g.group_id order by g.group_id)
+                    from navigation_item_groups g
+                   where g.item_id = n.id),
+                 '{}'::int[]
+               ) as group_ids
+          from navigation_items n
+         order by n.display_order, n.id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map(toRow)
+  }
+
+  /**
+   * Bring the plugin-owned rows into line with what the installed plugins ask
+   * for. An item's row is created once and then belongs to the operator: its
+   * label, order, nesting, audience and visibility survive every redeploy,
+   * because only the address a plugin owns is refreshed here. A row whose
+   * plugin is gone goes with it.
+   */
+  async syncPluginItems(declared: readonly PluginNavigationRow[]): Promise<{
+    readonly added: readonly string[]
+    readonly removed: readonly string[]
+  }> {
+    const existing = (await this.list()).filter((row) => row.key?.startsWith('plugin.') === true)
+    const wanted = new Map(declared.map((item) => [item.key, item]))
+
+    const removed = existing.filter((row) => !wanted.has(row.key as string))
+    for (const row of removed) await this.delete(row.id)
+
+    const added: string[] = []
+
+    const topLevelIds = new Map(
+      existing
+        .filter((row) => row.parentId === null)
+        .map((row) => [row.key as string, row.id] as const),
+    )
+    const inCreationOrder = [...declared].sort(
+      (a, b) => Number(a.parentKey !== null) - Number(b.parentKey !== null),
+    )
+
+    for (const item of inCreationOrder) {
+      const current = existing.find((row) => row.key === item.key)
+
+      if (current === undefined) {
+        const parentId = item.parentKey === null ? null : (topLevelIds.get(item.parentKey) ?? null)
+        const rows = resultRows(
+          await this.db.execute(sql`
+            insert into navigation_items (key, parent_id, label, href, display_order, audience)
+            values (${item.key}, ${parentId}, '', ${item.href},
+                    ${this.lastPlace(parentId)}, ${item.audience})
+            returning id
+          `),
+        ) as Array<{ id: number }>
+        if (parentId === null) topLevelIds.set(item.key, Number(rows[0]?.id))
+        added.push(item.key)
+        continue
+      }
+
+      if (current.href !== item.href) {
+        await this.db.execute(sql`
+          update navigation_items set href = ${item.href} where id = ${current.id}
+        `)
+      }
+    }
+
+    return { added, removed: removed.map((row) => row.key as string) }
+  }
+
+  async create(input: NavigationItemInput): Promise<number> {
+    assertValid(input, null)
+    await this.assertParentUsable(input.parentId, null)
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into navigation_items (key, parent_id, label, href, display_order,
+                                      audience, new_tab, enabled)
+        values (null, ${input.parentId}, ${input.label}, ${input.href},
+                ${this.lastPlace(input.parentId)},
+                ${input.audience}, ${input.newTab}, ${input.enabled})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    const id = Number(rows[0]?.id)
+    await this.setGroups(id, input.visibleToGroups)
+    return id
+  }
+
+  async update(id: number, input: NavigationItemInput): Promise<void> {
+    const current = await this.find(id)
+    if (current === null) throw new ValidationError(msg('error.db.such-navigation-item'))
+
+    assertValid(input, current.key)
+    await this.assertParentUsable(input.parentId, id)
+
+    const moved = input.parentId !== current.parentId
+
+    await this.db.execute(sql`
+      update navigation_items
+         set parent_id = ${input.parentId}, label = ${input.label}, href = ${input.href},
+             audience = ${input.audience}, new_tab = ${input.newTab},
+             enabled = ${input.enabled}
+             ${moved ? sql`, display_order = ${this.lastPlace(input.parentId)}` : sql``}
+       where id = ${id}
+    `)
+
+    await this.setGroups(id, input.visibleToGroups)
+  }
+
+  async arrange(id: number, target: NavigationDropTarget): Promise<void> {
+    const rows = await this.list()
+
+    const row = rows.find((entry) => entry.id === id)
+    if (row === undefined) throw new ValidationError(msg('error.db.such-navigation-item'))
+
+    if (target.parentId !== null) {
+      const parent = rows.find((entry) => entry.id === target.parentId)
+      if (parent === undefined || parent.id === id || parent.parentId !== null) {
+        throw new ValidationError(msg('error.db.navigation-item-parent-top-level'))
+      }
+      if (rows.some((entry) => entry.parentId === id)) {
+        throw new ValidationError(msg('error.db.navigation-item-with-items-under'))
+      }
+    }
+
+    const siblings = rows
+      .filter((entry) => entry.parentId === target.parentId && entry.id !== id)
+      .map((entry) => entry.id)
+
+    const at = target.afterId === null ? 0 : siblings.indexOf(target.afterId) + 1 || siblings.length
+    siblings.splice(at, 0, id)
+
+    await this.db.transaction(async (tx) => {
+      await tx.execute(sql`
+        update navigation_items set parent_id = ${target.parentId} where id = ${id}
+      `)
+
+      for (const [place, sibling] of siblings.entries()) {
+        await tx.execute(sql`
+          update navigation_items set display_order = ${place * 10} where id = ${sibling}
+        `)
+      }
+    })
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.db.execute(sql`delete from navigation_items where id = ${id}`)
+  }
+
+  private lastPlace(parentId: number | null): SQL {
+    return sql`(select coalesce(max(display_order), -10) + 10 from navigation_items
+                 where parent_id is not distinct from ${parentId})`
+  }
+
+  private async assertParentUsable(parentId: number | null, id: number | null): Promise<void> {
+    if (parentId === null) return
+
+    const rows = await this.list()
+
+    const parent = rows.find((row) => row.id === parentId)
+    if (parent === undefined || parent.id === id || parent.parentId !== null) {
+      throw new ValidationError(msg('error.db.navigation-item-parent-top-level'))
+    }
+    if (id !== null && rows.some((row) => row.parentId === id)) {
+      throw new ValidationError(msg('error.db.navigation-item-with-items-under'))
+    }
+  }
+
+  private async find(id: number): Promise<NavigationItemRow | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, key, parent_id, label, href, display_order, audience, new_tab, enabled,
+               '{}'::int[] as group_ids
+          from navigation_items
+         where id = ${id}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    return row === undefined ? null : toRow(row)
+  }
+
+  private async setGroups(id: number, groupIds: readonly number[]): Promise<void> {
+    await this.db.execute(sql`delete from navigation_item_groups where item_id = ${id}`)
+
+    const wanted = [...new Set(groupIds)]
+    if (wanted.length === 0) return
+
+    await this.db.execute(sql`
+      insert into navigation_item_groups (item_id, group_id)
+      select ${id}, id from usergroups where id in ${idList(wanted)}
+    `)
+  }
+}
+
+function assertValid(input: NavigationItemInput, key: string | null): void {
+  if (key === null && input.label.trim() === '') {
+    throw new ValidationError(msg('error.db.navigation-item-needs-label'))
+  }
+  if (input.href.trim() === '') {
+    throw new ValidationError(msg('error.db.navigation-item-needs-address'))
+  }
+}

package/src/notification-repo.ts

@@ -0,0 +1,402 @@
+import { sql } from 'drizzle-orm'
+
+import type {
+  DeliverableNotification,
+  NotificationChannel,
+  NotificationChannelPreference,
+  NotificationData,
+  NotificationPage,
+  NotificationRecord,
+  NotificationRepository,
+  PushSubscriptionRecord,
+  RaiseInput,
+  RaiseResult,
+  SavePushSubscriptionInput,
+} from '@meith/notifications'
+import { notificationKind } from '@meith/notifications'
+
+import type { Database } from './client'
+import { decodeCursor, encodeCursor } from './cursor'
+import { resultRows } from './result-rows'
+import { toDate, toNullableDate } from './row-values'
+
+interface RawNotification {
+  id: number
+  user_id: number
+  kind: string
+  data: unknown
+  href: string | null
+  occurrences: number
+  created_at: string | Date
+  updated_at: string | Date
+  read_at: string | Date | null
+}
+
+function toData(value: unknown): NotificationData {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? (value as NotificationData)
+    : {}
+}
+
+function toChannel(value: boolean | null): boolean | null {
+  return value === null ? null : value === true
+}
+
+function toRecord(row: RawNotification): NotificationRecord {
+  return {
+    id: Number(row.id),
+    userId: Number(row.user_id),
+    kind: row.kind,
+    data: toData(row.data),
+    href: row.href,
+    occurrences: Number(row.occurrences),
+    createdAt: toDate(row.created_at),
+    updatedAt: toDate(row.updated_at),
+    readAt: toNullableDate(row.read_at),
+  }
+}
+
+const SELECT_NOTIFICATION = sql`
+  select n.id, n.user_id, n.kind, n.data, n.href, n.occurrences,
+         n.created_at, n.updated_at, n.read_at
+    from notifications n
+`
+
+export class PostgresNotificationRepository implements NotificationRepository {
+  constructor(private readonly db: Database) {}
+
+  async raise(input: RaiseInput): Promise<RaiseResult> {
+    return this.db.transaction(async (tx) => {
+      const payload = JSON.stringify(input.data)
+
+      const rows = resultRows(
+        input.dedupeKey === null
+          ? await tx.execute(sql`
+              insert into notifications
+                     (user_id, kind, data, href, dedupe_key, created_at, updated_at)
+              values (${input.userId}, ${input.kind}, ${payload}::jsonb, ${input.href},
+                      null, ${input.at}, ${input.at})
+              returning id, occurrences
+            `)
+          : await tx.execute(sql`
+              insert into notifications
+                     (user_id, kind, data, href, dedupe_key, created_at, updated_at)
+              values (${input.userId}, ${input.kind}, ${payload}::jsonb, ${input.href},
+                      ${input.dedupeKey}, ${input.at}, ${input.at})
+                  on conflict (user_id, dedupe_key)
+                     where read_at is null and dedupe_key is not null
+                  do update
+                    set occurrences = notifications.occurrences + 1,
+                        /*
+                         * The newest facts win: an administrator reading "this
+                         * task failed 40 times" wants the *last* error, not the
+                         * first one from six hours ago.
+                         */
+                        data = excluded.data,
+                        href = excluded.href,
+                        updated_at = excluded.updated_at
+              returning id, occurrences
+            `),
+      ) as Array<{ id: number; occurrences: number }>
+
+      const row = rows[0]
+      if (row === undefined) throw new Error('Notification insert returned no row')
+
+      const notificationId = Number(row.id)
+      const coalesced = Number(row.occurrences) > 1
+
+      const emailQueued = input.email && !coalesced
+      const pushQueued = input.push && !coalesced
+
+      if (emailQueued || pushQueued) {
+        await tx.execute(sql`
+          insert into outbox (topic, payload)
+          values (
+            'notification.created',
+            ${JSON.stringify({
+              notificationId,
+              userId: input.userId,
+              kind: input.kind,
+            })}::jsonb
+          )
+        `)
+      }
+
+      return { notificationId, coalesced, emailQueued, pushQueued }
+    })
+  }
+
+  async listFor(
+    userId: number,
+    options: {
+      readonly limit: number
+      readonly after?: string
+      readonly offset?: number
+    },
+  ): Promise<NotificationPage> {
+    const cursor = options.after === undefined ? null : decodeCursor(options.after)
+    const after = cursor ? sql`and (n.created_at, n.id) < (${cursor.at}, ${cursor.id})` : sql``
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        ${SELECT_NOTIFICATION}
+         where n.user_id = ${userId} ${after}
+         order by n.created_at desc, n.id desc
+         limit ${options.limit + 1} offset ${options.offset ?? 0}
+      `),
+    ) as RawNotification[]
+
+    const page = rows.slice(0, options.limit).map(toRecord)
+    const last = page.at(-1)
+    return rows.length > options.limit && last
+      ? { rows: page, nextCursor: encodeCursor(last.createdAt, last.id) }
+      : { rows: page }
+  }
+
+  async countFor(userId: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as total from notifications where user_id = ${userId}
+      `),
+    ) as Array<{ total: number }>
+
+    return Number(rows[0]?.total ?? 0)
+  }
+
+  async unreadCount(userId: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as unread
+          from notifications
+         where user_id = ${userId} and read_at is null
+      `),
+    ) as Array<{ unread: number }>
+    return Number(rows[0]?.unread ?? 0)
+  }
+
+  async markRead(userId: number, notificationId: number): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update notifications
+           set read_at = now()
+         where id = ${notificationId} and user_id = ${userId} and read_at is null
+        returning id
+      `),
+    ) as Array<{ id: number }>
+    return rows.length > 0
+  }
+
+  async markAllRead(userId: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update notifications
+           set read_at = now()
+         where user_id = ${userId} and read_at is null
+        returning id
+      `),
+    ) as Array<{ id: number }>
+    return rows.length
+  }
+
+  async preferencesFor(
+    userId: number,
+  ): Promise<ReadonlyMap<string, NotificationChannelPreference>> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select kind, email, push from notification_preferences where user_id = ${userId}
+      `),
+    ) as Array<{ kind: string; email: boolean | null; push: boolean | null }>
+
+    return new Map(
+      rows.map((row) => [row.kind, { email: toChannel(row.email), push: toChannel(row.push) }]),
+    )
+  }
+
+  async savePreferences(
+    userId: number,
+    channel: NotificationChannel,
+    entries: ReadonlyMap<string, boolean>,
+  ): Promise<void> {
+    if (entries.size === 0) return
+
+    const values = sql.join(
+      [...entries].map(([kind, on]) => sql`(${userId}, ${kind}, ${on}, now())`),
+      sql`, `,
+    )
+
+    await this.db.execute(
+      channel === 'email'
+        ? sql`
+            insert into notification_preferences (user_id, kind, email, updated_at)
+            values ${values}
+                on conflict (user_id, kind)
+                do update set email = excluded.email, updated_at = now()
+          `
+        : sql`
+            insert into notification_preferences (user_id, kind, push, updated_at)
+            values ${values}
+                on conflict (user_id, kind)
+                do update set push = excluded.push, updated_at = now()
+          `,
+    )
+  }
+
+  async savePushSubscription(input: SavePushSubscriptionInput): Promise<void> {
+    await this.db.execute(sql`
+      insert into push_subscriptions
+             (user_id, endpoint, p256dh, auth, created_at, last_seen_at)
+      values (${input.userId}, ${input.endpoint}, ${input.p256dh}, ${input.auth},
+              ${input.at}, ${input.at})
+          on conflict (endpoint)
+          do update set user_id = excluded.user_id,
+                        p256dh = excluded.p256dh,
+                        auth = excluded.auth,
+                        last_seen_at = excluded.last_seen_at
+    `)
+  }
+
+  async removePushSubscription(userId: number, endpoint: string): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from push_subscriptions
+         where user_id = ${userId} and endpoint = ${endpoint}
+        returning id
+      `),
+    ) as Array<{ id: number }>
+    return rows.length > 0
+  }
+
+  async pushSubscriptionsFor(userId: number): Promise<readonly PushSubscriptionRecord[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, user_id, endpoint, p256dh, auth, created_at, last_seen_at
+          from push_subscriptions
+         where user_id = ${userId}
+         order by id
+      `),
+    ) as Array<{
+      id: number
+      user_id: number
+      endpoint: string
+      p256dh: string
+      auth: string
+      created_at: string | Date
+      last_seen_at: string | Date
+    }>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      userId: Number(row.user_id),
+      endpoint: row.endpoint,
+      p256dh: row.p256dh,
+      auth: row.auth,
+      createdAt: toDate(row.created_at),
+      lastSeenAt: toDate(row.last_seen_at),
+    }))
+  }
+
+  async countPushSubscriptions(userId: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as total from push_subscriptions where user_id = ${userId}
+      `),
+    ) as Array<{ total: number }>
+    return Number(rows[0]?.total ?? 0)
+  }
+
+  async prunePushSubscription(id: number): Promise<void> {
+    await this.db.execute(sql`delete from push_subscriptions where id = ${id}`)
+  }
+
+  async touchPushSubscription(id: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update push_subscriptions set last_seen_at = ${at} where id = ${id}
+    `)
+  }
+
+  async findForDelivery(notificationId: number): Promise<DeliverableNotification | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select n.id, n.user_id, n.kind, n.data, n.href, n.occurrences,
+               n.created_at, n.updated_at, n.read_at, n.email_sent_at, n.push_sent_at,
+               u.username, u.email, u.locale, u.state,
+               p.email as email_preference, p.push as push_preference
+          from notifications n
+          join users u on u.id = n.user_id
+          left join notification_preferences p
+                 on p.user_id = n.user_id and p.kind = n.kind
+         where n.id = ${notificationId}
+      `),
+    ) as Array<
+      RawNotification & {
+        email_sent_at: string | Date | null
+        push_sent_at: string | Date | null
+        username: string
+        email: string
+        locale: string
+        state: string
+        email_preference: boolean | null
+        push_preference: boolean | null
+      }
+    >
+
+    const row = rows[0]
+    if (row === undefined) return null
+    if (row.state === 'deleted') return null
+
+    const spec = notificationKind(row.kind)
+
+    return {
+      notification: toRecord(row),
+      recipient: {
+        userId: Number(row.user_id),
+        username: row.username,
+        email: row.email,
+        locale: row.locale,
+      },
+      emailEnabled: row.email_preference ?? spec?.emailByDefault ?? false,
+      emailSentAt: toNullableDate(row.email_sent_at),
+      pushEnabled: row.push_preference ?? spec?.pushByDefault ?? false,
+      pushSentAt: toNullableDate(row.push_sent_at),
+    }
+  }
+
+  async markEmailSent(notificationId: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update notifications set email_sent_at = ${at} where id = ${notificationId}
+    `)
+  }
+
+  async markPushSent(notificationId: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update notifications set push_sent_at = ${at} where id = ${notificationId}
+    `)
+  }
+
+  async administratorIds(limit: number): Promise<readonly number[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select u.id
+          from users u
+         where u.state = 'active'
+           and exists (
+                 select 1
+                   from usergroups g
+                  where g.can_access_admin_cp
+                    and (
+                      g.id = u.primary_group_id
+                      or g.id in (
+                        select m.group_id
+                          from user_group_memberships m
+                         where m.user_id = u.id
+                      )
+                    )
+               )
+         order by u.id
+         limit ${limit}
+      `),
+    ) as Array<{ id: number }>
+
+    return rows.map((row) => Number(row.id))
+  }
+}

package/src/orphan-keys.ts

@@ -0,0 +1,19 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { textList } from './sql-lists'
+
+export async function rememberOrphanKey(db: Database, key: string): Promise<void> {
+  await db.execute(sql`
+    insert into attachment_orphans (storage_key) values (${key})
+    on conflict (storage_key) do nothing
+  `)
+}
+
+export async function forgetOrphanKeys(db: Database, keys: readonly string[]): Promise<void> {
+  if (keys.length === 0) return
+  await db.execute(sql`
+    delete from attachment_orphans
+     where storage_key in ${textList(keys)}
+  `)
+}