@meith/db 0.16.0

package/src/install-repo.ts

@@ -0,0 +1,67 @@
+import { sql } from 'drizzle-orm'
+import postgres from 'postgres'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export const INSTALL_LOCK_KEY = '8626403014885544245'
+
+export async function isInstalled(db: Database): Promise<boolean> {
+  try {
+    const rows = (await db.execute(
+      sql`select 1 from install_state where id = 1`,
+    )) as unknown as unknown[]
+    return rows.length > 0
+  } catch {
+    return false
+  }
+}
+
+export async function countUsers(db: Database): Promise<number | null> {
+  try {
+    const rows = (await db.execute(sql`select count(*)::int as total from users`)) as unknown as {
+      total: number
+    }[]
+    return rows[0]?.total ?? 0
+  } catch {
+    return null
+  }
+}
+
+export async function canConnect(db: Database): Promise<boolean> {
+  try {
+    await db.execute(sql`select 1`)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function markInstalled(db: Database, version: string): Promise<boolean> {
+  const rows = resultRows(
+    await db.execute(sql`
+      insert into install_state (id, installed_version)
+      values (1, ${version})
+      on conflict (id) do nothing
+      returning id
+    `),
+  )
+
+  return rows.length > 0
+}
+
+export async function withInstallLock<T>(url: string, body: () => Promise<T>): Promise<T | null> {
+  const client = postgres(url, { max: 1, prepare: false, onnotice: () => {} })
+
+  try {
+    const rows = await client`
+      select pg_try_advisory_lock(${INSTALL_LOCK_KEY}::bigint) as locked
+    `
+
+    if (rows[0]?.locked !== true) return null
+
+    return await body()
+  } finally {
+    await client.end({ timeout: 5 })
+  }
+}

package/src/latest-repo.ts

@@ -0,0 +1,115 @@
+import { sql } from 'drizzle-orm'
+
+import type { ContentScope } from '@meith/core'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+import { audienceIsEmpty, inAudience } from './thread-audience'
+import { visibleIn } from './visibility'
+
+export interface LatestScope {
+  readonly forumIds: readonly number[]
+  readonly ownThreadsOnlyForumIds: readonly number[]
+  readonly viewerUserId: number | null
+  readonly content: ContentScope
+}
+
+export interface LatestThreadRow {
+  readonly threadId: number
+  readonly title: string
+  readonly slug: string
+  readonly forumId: number
+  readonly forumTitle: string
+  readonly forumSlug: string
+  readonly authorUserId: number | null
+  readonly authorUsername: string
+  readonly replyCount: number
+  readonly createdAt: Date
+}
+
+export interface LatestPostRow {
+  readonly postId: number
+  readonly threadId: number
+  readonly threadTitle: string
+  readonly threadSlug: string
+  readonly forumId: number
+  readonly forumTitle: string
+  readonly forumSlug: string
+  readonly authorUserId: number | null
+  readonly authorUsername: string
+  readonly createdAt: Date
+  readonly messageSource: string
+}
+
+const EXCERPT_CHARS = 300
+
+export class PostgresLatestRepository {
+  constructor(private readonly db: Database) {}
+
+  async threads(limit: number, scope: LatestScope): Promise<readonly LatestThreadRow[]> {
+    if (audienceIsEmpty(scope)) return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select t.id, t.title, t.slug, t.forum_id, f.title as forum_title,
+               f.slug as forum_slug, t.author_user_id, t.author_username,
+               t.reply_count, t.created_at
+          from threads t
+          join forums f on f.id = t.forum_id
+         where ${inAudience(sql`t.forum_id`, sql`t.author_user_id`, scope)}
+           and ${visibleIn(sql`t.visibility`, scope.content)}
+         order by t.id desc
+         limit ${limit}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      threadId: Number(row.id),
+      title: String(row.title),
+      slug: String(row.slug),
+      forumId: Number(row.forum_id),
+      forumTitle: String(row.forum_title),
+      forumSlug: String(row.forum_slug),
+      authorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+      authorUsername: String(row.author_username),
+      replyCount: Number(row.reply_count),
+      createdAt: toDate(row.created_at),
+    }))
+  }
+
+  async posts(limit: number, scope: LatestScope): Promise<readonly LatestPostRow[]> {
+    if (audienceIsEmpty(scope)) return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select p.id, p.thread_id, p.author_user_id, p.author_username, p.created_at,
+               left(p.message, ${EXCERPT_CHARS}) as message,
+               t.title as thread_title, t.slug as thread_slug,
+               t.forum_id, f.title as forum_title, f.slug as forum_slug
+          from posts p
+          join threads t on t.id = p.thread_id
+          join forums f on f.id = t.forum_id
+         where ${inAudience(sql`t.forum_id`, sql`t.author_user_id`, scope)}
+           and ${visibleIn(sql`t.visibility`, scope.content)}
+           and ${visibleIn(sql`p.visibility`, scope.content)}
+         order by p.id desc
+         limit ${limit}
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      postId: Number(row.id),
+      threadId: Number(row.thread_id),
+      threadTitle: String(row.thread_title),
+      threadSlug: String(row.thread_slug),
+      forumId: Number(row.forum_id),
+      forumTitle: String(row.forum_title),
+      forumSlug: String(row.forum_slug),
+      authorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+      authorUsername: String(row.author_username),
+      createdAt: toDate(row.created_at),
+      messageSource: String(row.message),
+    }))
+  }
+}

package/src/maintenance-repo.ts

@@ -0,0 +1,54 @@
+import { and, isNotNull, lt, or, sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { credentialTokens, sessions } from './schema'
+
+export class PostgresMaintenanceRepository {
+  constructor(private readonly db: Database) {}
+
+  async pruneSessions(now: Date, limit = 5000, revokedGraceHours = 24): Promise<number> {
+    const revokedBefore = new Date(now.getTime() - revokedGraceHours * 3_600_000)
+
+    const result = await this.db.execute(sql`
+      delete from ${sessions}
+       where id in (
+         select id from ${sessions}
+          where expires_at <= ${now}
+             or (revoked_at is not null and revoked_at <= ${revokedBefore})
+          limit ${limit}
+       )
+      returning id
+    `)
+
+    return resultRows(result).length
+  }
+
+  async pruneExpiredTokens(now: Date, limit = 5000): Promise<number> {
+    const result = await this.db.execute(sql`
+      delete from ${credentialTokens}
+       where id in (
+         select id from ${credentialTokens}
+          where expires_at <= ${now} or consumed_at is not null
+          limit ${limit}
+       )
+      returning id
+    `)
+
+    return resultRows(result).length
+  }
+
+  async countPrunableSessions(now: Date, revokedGraceHours = 24): Promise<number> {
+    const revokedBefore = new Date(now.getTime() - revokedGraceHours * 3_600_000)
+    const rows = await this.db
+      .select({ id: sessions.id })
+      .from(sessions)
+      .where(
+        or(
+          lt(sessions.expiresAt, now),
+          and(isNotNull(sessions.revokedAt), lt(sessions.revokedAt, revokedBefore)),
+        ),
+      )
+    return rows.length
+  }
+}

package/src/marketplace-repo.ts

@@ -0,0 +1,111 @@
+import { sql } from 'drizzle-orm'
+
+import type {
+  CachedMarketplace,
+  MarketplaceCacheRepository,
+  MarketplaceFeed,
+} from '@meith/marketplace'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+interface Row {
+  readonly feed: unknown
+  readonly source_url: string | null
+  readonly fetched_at: string | null
+  readonly error: string | null
+  readonly error_at: string | null
+  readonly notified_updates: unknown
+}
+
+function toCached(row: Row | undefined): CachedMarketplace {
+  if (row === undefined) {
+    return { feed: null, sourceUrl: null, fetchedAt: null, error: null, errorAt: null }
+  }
+
+  return {
+    feed: (row.feed as MarketplaceFeed | null) ?? null,
+    sourceUrl: row.source_url,
+    fetchedAt: row.fetched_at === null ? null : new Date(row.fetched_at),
+    error: row.error,
+    errorAt: row.error_at === null ? null : new Date(row.error_at),
+  }
+}
+
+/**
+ * The single-row cache behind the Browse tab — see the `marketplace_catalog`
+ * table comment in `packages/db/src/schema/platform.ts` for why a table
+ * rather than the generic `settings` store: this holds a whole feed
+ * document and fetch bookkeeping, not a board-operator preference.
+ */
+export class PostgresMarketplaceCacheRepository implements MarketplaceCacheRepository {
+  constructor(private readonly db: Database) {}
+
+  async read(): Promise<CachedMarketplace> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select feed, source_url, fetched_at, error, error_at, notified_updates
+          from marketplace_catalog
+         where id = 1
+      `),
+    ) as Row[]
+
+    return toCached(rows[0])
+  }
+
+  async saveFeed(input: {
+    readonly feed: MarketplaceFeed
+    readonly sourceUrl: string
+    readonly fetchedAt: Date
+  }): Promise<void> {
+    await this.db.execute(sql`
+      insert into marketplace_catalog (id, feed, source_url, fetched_at, error, error_at, updated_at)
+      values (1, ${JSON.stringify(input.feed)}::jsonb, ${input.sourceUrl}, ${input.fetchedAt}, null, null, now())
+      on conflict (id) do update
+        set feed = excluded.feed,
+            source_url = excluded.source_url,
+            fetched_at = excluded.fetched_at,
+            error = null,
+            error_at = null,
+            updated_at = now()
+    `)
+  }
+
+  async saveError(input: { readonly message: string; readonly at: Date }): Promise<void> {
+    await this.db.execute(sql`
+      insert into marketplace_catalog (id, error, error_at, updated_at)
+      values (1, ${input.message}, ${input.at}, now())
+      on conflict (id) do update
+        set error = excluded.error,
+            error_at = excluded.error_at,
+            updated_at = now()
+    `)
+  }
+
+  async hasNotified(key: string, version: string): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select 1
+          from marketplace_catalog
+         where id = 1
+           and notified_updates @> ${JSON.stringify([`${key}@${version}`])}::jsonb
+      `),
+    ) as unknown[]
+
+    return rows.length > 0
+  }
+
+  async markNotified(key: string, version: string): Promise<void> {
+    const marker = `${key}@${version}`
+    await this.db.execute(sql`
+      insert into marketplace_catalog (id, notified_updates, updated_at)
+      values (1, ${JSON.stringify([marker])}::jsonb, now())
+      on conflict (id) do update
+        set notified_updates = (
+              select jsonb_agg(distinct value)
+                from jsonb_array_elements(marketplace_catalog.notified_updates || excluded.notified_updates)
+            ),
+            updated_at = now()
+    `)
+  }
+}

package/src/member-profile-repo.ts

@@ -0,0 +1,82 @@
+import { sql } from 'drizzle-orm'
+
+import type {
+  MemberProfileRecord,
+  MemberProfileRepository,
+  MemberSuggestion,
+} from '@meith/accounts'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { displayGroupIdSql } from './staff-groups'
+
+function likePrefix(prefix: string): string {
+  return `${prefix.replaceAll('\\', '\\\\').replaceAll('%', '\\%').replaceAll('_', '\\_')}%`
+}
+
+interface RawProfile {
+  id: number
+  username: string
+  title: string | null
+  post_count: number
+  created_at: Date
+  last_active_at: Date | null
+  location: string | null
+  website: string | null
+  bio: string | null
+}
+
+export class PostgresMemberProfileRepository implements MemberProfileRepository {
+  constructor(private readonly db: Database) {}
+
+  async findPublicById(id: number): Promise<MemberProfileRecord | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select u.id, u.username, g.title, u.post_count, u.created_at,
+               u.last_active_at, u.location, u.website, u.bio
+          from users u
+          join usergroups p
+            on p.id = u.primary_group_id
+          left join usergroups g
+            on g.id = ${displayGroupIdSql('u', 'p')}
+         where u.id = ${id} and u.state <> 'deleted'
+         limit 1
+      `),
+    ) as RawProfile[]
+
+    const row = rows[0]
+    if (row === undefined) return null
+
+    return {
+      id: Number(row.id),
+      username: row.username,
+      title: row.title,
+      postCount: Number(row.post_count),
+      createdAt: new Date(row.created_at),
+      lastActiveAt: row.last_active_at === null ? null : new Date(row.last_active_at),
+      location: row.location,
+      website: row.website,
+      bio: row.bio,
+    }
+  }
+
+  async searchByUsernamePrefix(
+    prefix: string,
+    limit: number,
+  ): Promise<readonly MemberSuggestion[]> {
+    if (prefix === '') return []
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, username
+          from users
+         where state = 'active'
+           and username_lower like ${likePrefix(prefix.toLowerCase())}
+         order by username_lower
+         limit ${limit}
+      `),
+    ) as Array<{ id: number; username: string }>
+
+    return rows.map((row) => ({ id: Number(row.id), username: row.username }))
+  }
+}

package/src/member-settings-repo.ts

@@ -0,0 +1,160 @@
+import { sql } from 'drizzle-orm'
+
+import type { MemberGroupChoice, MemberSettings, MemberSettingsRepository } from '@meith/accounts'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { isStaffGroupSql } from './staff-groups'
+
+interface RawSettings {
+  id: number
+  email: string
+  timezone: string
+  locale: string
+  posts_per_page: number | null
+  threads_per_page: number | null
+  invisible: boolean
+  location: string | null
+  website: string | null
+  bio: string | null
+  display_group_id: number | null
+}
+
+interface RawGroupChoice {
+  id: number
+  title: string
+  is_primary: boolean
+  is_staff: boolean
+}
+
+export class PostgresMemberSettingsRepository implements MemberSettingsRepository {
+  constructor(private readonly db: Database) {}
+
+  async read(userId: number): Promise<MemberSettings | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, email, timezone, locale, posts_per_page, threads_per_page,
+               invisible, location, website, bio, display_group_id
+          from users
+         where id = ${userId} and state <> 'deleted'
+      `),
+    ) as RawSettings[]
+
+    const row = rows[0]
+    if (row === undefined) return null
+
+    return {
+      userId: Number(row.id),
+      email: row.email,
+      timezone: row.timezone,
+      locale: row.locale,
+      postsPerPage: row.posts_per_page === null ? null : Number(row.posts_per_page),
+      threadsPerPage: row.threads_per_page === null ? null : Number(row.threads_per_page),
+      invisible: row.invisible === true,
+      location: row.location,
+      website: row.website,
+      bio: row.bio,
+      displayGroupId: row.display_group_id === null ? null : Number(row.display_group_id),
+    }
+  }
+
+  async groupsHeldBy(userId: number): Promise<readonly MemberGroupChoice[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select g.id, g.title, (g.id = u.primary_group_id) as is_primary,
+               (${isStaffGroupSql('g')}) as is_staff
+          from users u
+          join usergroups g
+            on 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
+                 and (m.expires_at is null or m.expires_at > now())
+            )
+         where u.id = ${userId} and u.state <> 'deleted'
+         order by is_primary desc, g.display_order, g.title
+      `),
+    ) as RawGroupChoice[]
+
+    return rows.map((row) => ({
+      groupId: Number(row.id),
+      title: row.title,
+      isPrimary: row.is_primary === true,
+      isStaff: row.is_staff === true,
+    }))
+  }
+
+  async saveDisplayGroup(input: {
+    readonly userId: number
+    readonly displayGroupId: number | null
+  }): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set display_group_id = ${input.displayGroupId},
+             updated_at = now()
+       where id = ${input.userId}
+    `)
+  }
+
+  async saveProfile(input: {
+    readonly userId: number
+    readonly location: string | null
+    readonly website: string | null
+    readonly bio: string | null
+  }): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set location = ${input.location},
+             website = ${input.website},
+             bio = ${input.bio},
+             updated_at = now()
+       where id = ${input.userId}
+    `)
+  }
+
+  async saveOptions(input: {
+    readonly userId: number
+    readonly timezone: string
+    readonly locale: string
+    readonly postsPerPage: number | null
+    readonly threadsPerPage: number | null
+    readonly invisible: boolean
+  }): Promise<void> {
+    await this.db.execute(sql`
+      update users
+         set timezone = ${input.timezone},
+             locale = ${input.locale},
+             posts_per_page = ${input.postsPerPage},
+             threads_per_page = ${input.threadsPerPage},
+             invisible = ${input.invisible},
+             updated_at = now()
+       where id = ${input.userId}
+    `)
+  }
+
+  async adoptEmail(input: {
+    readonly userId: number
+    readonly email: string
+    readonly emailLower: string
+  }): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update users u
+           set email = ${input.email},
+               email_lower = ${input.emailLower},
+               email_verified_at = now(),
+               updated_at = now()
+         where u.id = ${input.userId}
+           and u.state <> 'deleted'
+           and not exists (
+             select 1 from users other
+              where other.email_lower = ${input.emailLower} and other.id <> u.id
+           )
+        returning u.id
+      `),
+    ) as Array<{ id: number }>
+
+    return rows.length > 0
+  }
+}