@meith/db 0.16.0

package/src/antispam-repo.ts

@@ -0,0 +1,145 @@
+import { sql } from 'drizzle-orm'
+
+import type { CaptchaQuestion, RateLimitStore, RateLimitSubject } from '@meith/antispam'
+import { ValidationError } from '@meith/core'
+import { msg } from '@meith/i18n'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+
+export class PostgresRateLimitBucketStore implements RateLimitStore {
+  constructor(private readonly db: Database) {}
+
+  async spend(subject: RateLimitSubject, windowStart: Date, cost: number): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into rate_limits (scope, subject, window_start, used)
+        values (${subject.scope}, ${subject.subject}, ${windowStart}, ${cost})
+        on conflict (scope, subject, window_start)
+          do update set used = rate_limits.used + ${cost}
+        returning used
+      `),
+    ) as Array<{ used: number }>
+
+    return Number(rows[0]?.used ?? cost)
+  }
+
+  async peek(subject: RateLimitSubject, windowStart: Date): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select used from rate_limits
+         where scope = ${subject.scope}
+           and subject = ${subject.subject}
+           and window_start = ${windowStart}
+      `),
+    ) as Array<{ used: number }>
+
+    return Number(rows[0]?.used ?? 0)
+  }
+
+  async prune(before: Date, limit = 5000): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        delete from rate_limits
+         where ctid in (
+           select ctid from rate_limits where window_start < ${before} limit ${limit}
+         )
+        returning subject
+      `),
+    ) as Array<unknown>
+
+    return rows.length
+  }
+}
+
+export interface CaptchaQuestionRow extends CaptchaQuestion {
+  readonly enabled: boolean
+}
+
+function splitAnswers(raw: string): readonly string[] {
+  return raw
+    .split('\n')
+    .map((answer) => answer.trim())
+    .filter((answer) => answer !== '')
+}
+
+export class PostgresCaptchaQuestionRepository {
+  constructor(private readonly db: Database) {}
+
+  async active(): Promise<readonly CaptchaQuestion[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, question, answers from captcha_questions
+         where enabled = true and question <> '' and answers <> ''
+         order by id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows
+      .map((row) => ({
+        id: Number(row.id),
+        question: String(row.question),
+        answers: splitAnswers(String(row.answers)),
+      }))
+      .filter((question) => question.answers.length > 0)
+  }
+
+  async list(): Promise<readonly CaptchaQuestionRow[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select id, question, answers, enabled from captcha_questions order by id
+      `),
+    ) as Array<Record<string, unknown>>
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      question: String(row.question),
+      answers: splitAnswers(String(row.answers)),
+      enabled: row.enabled === true,
+    }))
+  }
+
+  async create(input: { readonly question: string; readonly answers: string }): Promise<number> {
+    assertUsable(input.question, input.answers)
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        insert into captcha_questions (question, answers)
+        values (${input.question.trim()}, ${input.answers})
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    return Number(rows[0]?.id)
+  }
+
+  async update(
+    id: number,
+    input: { readonly question: string; readonly answers: string; readonly enabled: boolean },
+  ): Promise<void> {
+    assertUsable(input.question, input.answers)
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        update captcha_questions
+           set question = ${input.question.trim()}, answers = ${input.answers},
+               enabled = ${input.enabled}
+         where id = ${id}
+        returning id
+      `),
+    ) as Array<{ id: number }>
+
+    if (rows[0] === undefined) throw new ValidationError(msg('error.db.such-question'))
+  }
+
+  async delete(id: number): Promise<void> {
+    await this.db.execute(sql`delete from captcha_questions where id = ${id}`)
+  }
+}
+
+function assertUsable(question: string, answers: string): void {
+  if (question.trim() === '') throw new ValidationError(msg('error.db.question-needs-asked'))
+  if (splitAnswers(answers).length === 0) {
+    throw new ValidationError(msg('error.db.question-needs-at-least-one'))
+  }
+}

package/src/api-repo.ts

@@ -0,0 +1,276 @@
+import { sql } from 'drizzle-orm'
+
+import type { ApiTokenRecord, RateLimitStore, Scope } from '@meith/api'
+
+import type { Database } from './client'
+
+interface TokenRow {
+  id: number
+  user_id: number
+  name: string
+  lookup: string
+  secret_hash: string
+  scopes: unknown
+  expires_at: Date | null
+  revoked_at: Date | null
+}
+
+function parseScopes(raw: unknown, known: (value: string) => value is Scope): readonly Scope[] {
+  if (!Array.isArray(raw)) return []
+  return raw.filter((value): value is Scope => typeof value === 'string' && known(value))
+}
+
+export interface ApiTokenSummary {
+  readonly id: number
+  readonly userId: number
+  readonly username: string
+  readonly name: string
+  readonly lookup: string
+  readonly scopes: readonly Scope[]
+  readonly createdAt: Date
+  readonly expiresAt: Date | null
+  readonly revokedAt: Date | null
+  readonly lastUsedAt: Date | null
+}
+
+export class PostgresApiTokenRepository {
+  constructor(
+    private readonly db: Database,
+    private readonly isScope: (value: string) => value is Scope,
+  ) {}
+
+  async findByLookup(lookup: string): Promise<ApiTokenRecord | null> {
+    const rows = (await this.db.execute(sql`
+      select id, user_id, name, lookup, secret_hash, scopes, expires_at, revoked_at
+      from api_tokens
+      where lookup = ${lookup}
+      limit 1
+    `)) as unknown as TokenRow[]
+
+    const row = rows[0]
+    if (row === undefined) return null
+
+    return {
+      id: row.id,
+      userId: row.user_id,
+      name: row.name,
+      lookup: row.lookup,
+      secretHash: row.secret_hash,
+      scopes: parseScopes(row.scopes, this.isScope),
+      expiresAt: row.expires_at,
+      revokedAt: row.revoked_at,
+    }
+  }
+
+  async listAll(limit = 200): Promise<readonly ApiTokenSummary[]> {
+    const rows = (await this.db.execute(sql`
+      select t.id, t.user_id, u.username, t.name, t.lookup, t.scopes,
+             t.created_at, t.expires_at, t.revoked_at, t.last_used_at
+      from api_tokens t
+      join users u on u.id = t.user_id
+      order by t.revoked_at nulls first, t.created_at desc
+      limit ${limit}
+    `)) as unknown as Array<{
+      id: number
+      user_id: number
+      username: string
+      name: string
+      lookup: string
+      scopes: unknown
+      created_at: Date | string
+      expires_at: Date | string | null
+      revoked_at: Date | string | null
+      last_used_at: Date | string | null
+    }>
+
+    return rows.map((row) => ({
+      id: row.id,
+      userId: row.user_id,
+      username: row.username,
+      name: row.name,
+      lookup: row.lookup,
+      scopes: parseScopes(row.scopes, this.isScope),
+      createdAt: new Date(row.created_at),
+      expiresAt: row.expires_at === null ? null : new Date(row.expires_at),
+      revokedAt: row.revoked_at === null ? null : new Date(row.revoked_at),
+      lastUsedAt: row.last_used_at === null ? null : new Date(row.last_used_at),
+    }))
+  }
+
+  async create(input: {
+    readonly userId: number
+    readonly name: string
+    readonly lookup: string
+    readonly secretHash: string
+    readonly scopes: readonly Scope[]
+    readonly expiresAt: Date | null
+  }): Promise<number> {
+    const rows = (await this.db.execute(sql`
+      insert into api_tokens (user_id, name, lookup, secret_hash, scopes, expires_at)
+      values (${input.userId}, ${input.name}, ${input.lookup}, ${input.secretHash},
+              ${JSON.stringify(input.scopes)}, ${input.expiresAt})
+      returning id
+    `)) as unknown as Array<{ id: number }>
+
+    return rows[0]!.id
+  }
+
+  async revoke(id: number, at: Date): Promise<boolean> {
+    const rows = (await this.db.execute(sql`
+      update api_tokens set revoked_at = ${at}
+      where id = ${id} and revoked_at is null
+      returning id
+    `)) as unknown as Array<{ id: number }>
+
+    return rows.length > 0
+  }
+
+  async touch(id: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update api_tokens
+      set last_used_at = ${at}
+      where id = ${id}
+        and (last_used_at is null or last_used_at < ${new Date(at.getTime() - 60_000)})
+    `)
+  }
+}
+
+export class PostgresRateLimitStore implements RateLimitStore {
+  constructor(private readonly db: Database) {}
+
+  async spend(tokenId: number, windowStart: Date, cost: number): Promise<number> {
+    const rows = (await this.db.execute(sql`
+      insert into api_rate_limits (token_id, window_start, used)
+      values (${tokenId}, ${windowStart}, ${cost})
+      on conflict (token_id, window_start)
+        do update set used = api_rate_limits.used + ${cost}
+      returning used
+    `)) as unknown as { used: number }[]
+
+    return rows[0]?.used ?? cost
+  }
+
+  async peek(tokenId: number, windowStart: Date): Promise<number> {
+    const rows = (await this.db.execute(sql`
+      select used from api_rate_limits
+       where token_id = ${tokenId} and window_start = ${windowStart}
+    `)) as unknown as { used: number }[]
+
+    return rows[0]?.used ?? 0
+  }
+
+  async prune(before: Date, limit = 5000): Promise<number> {
+    const rows = (await this.db.execute(sql`
+      delete from api_rate_limits
+      where ctid in (
+        select ctid from api_rate_limits where window_start < ${before} limit ${limit}
+      )
+      returning token_id
+    `)) as unknown as unknown[]
+    return rows.length
+  }
+}
+
+export interface WebhookDeliveryRow {
+  readonly id: number
+  readonly webhookId: number
+  readonly deliveryId: string
+  readonly topic: string
+  readonly payload: Record<string, unknown>
+  readonly attempts: number
+  readonly url: string
+  readonly secret: string
+}
+
+export class PostgresWebhookRepository {
+  constructor(private readonly db: Database) {}
+
+  async enqueue(
+    topic: string,
+    deliveryId: string,
+    payload: Record<string, unknown>,
+  ): Promise<number> {
+    const rows = (await this.db.execute(sql`
+      insert into webhook_deliveries (webhook_id, delivery_id, topic, payload)
+      select w.id, ${deliveryId}, ${topic}, ${JSON.stringify(payload)}::jsonb
+      from webhooks w
+      where w.active = true and w.topics ? ${topic}
+      on conflict (webhook_id, delivery_id) do nothing
+      returning id
+    `)) as unknown as unknown[]
+
+    return rows.length
+  }
+
+  async claimDue(now: Date, limit: number): Promise<readonly WebhookDeliveryRow[]> {
+    const rows = (await this.db.execute(sql`
+      with due as (
+        select d.id
+        from webhook_deliveries d
+        where d.status = 'pending' and d.next_attempt_at <= ${now}
+        order by d.next_attempt_at
+        limit ${limit}
+        for update skip locked
+      )
+      update webhook_deliveries d
+      set attempts = d.attempts + 1
+      from due, webhooks w
+      where d.id = due.id and w.id = d.webhook_id
+      returning d.id, d.webhook_id, d.delivery_id, d.topic, d.payload, d.attempts, w.url, w.secret
+    `)) as unknown as {
+      id: number
+      webhook_id: number
+      delivery_id: string
+      topic: string
+      payload: Record<string, unknown>
+      attempts: number
+      url: string
+      secret: string
+    }[]
+
+    return rows.map((row) => ({
+      id: row.id,
+      webhookId: row.webhook_id,
+      deliveryId: row.delivery_id,
+      topic: row.topic,
+      payload: row.payload,
+      attempts: row.attempts,
+      url: row.url,
+      secret: row.secret,
+    }))
+  }
+
+  async markDelivered(id: number, status: number, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update webhook_deliveries
+      set status = 'delivered', last_status_code = ${status}, completed_at = ${at}, last_error = null
+      where id = ${id}
+    `)
+  }
+
+  async scheduleRetry(id: number, at: Date, status: number | null, error: string): Promise<void> {
+    await this.db.execute(sql`
+      update webhook_deliveries
+      set next_attempt_at = ${at}, last_status_code = ${status}, last_error = ${error}
+      where id = ${id}
+    `)
+  }
+
+  async markDead(id: number, status: number | null, error: string, at: Date): Promise<void> {
+    await this.db.execute(sql`
+      update webhook_deliveries
+      set status = 'dead', last_status_code = ${status}, last_error = ${error}, completed_at = ${at}
+      where id = ${id}
+    `)
+  }
+
+  async retryDead(id: number, at: Date): Promise<boolean> {
+    const rows = (await this.db.execute(sql`
+      update webhook_deliveries
+      set status = 'pending', attempts = 0, next_attempt_at = ${at}, last_error = null
+      where id = ${id} and status = 'dead'
+      returning id
+    `)) as unknown as unknown[]
+    return rows.length > 0
+  }
+}

package/src/attachment-admin-repo.ts

@@ -0,0 +1,161 @@
+import { sql } from 'drizzle-orm'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { likeFragment } from './user-admin-repo'
+
+export interface AttachmentAdminRow {
+  readonly id: number
+  readonly postId: number
+  readonly threadSlug: string | null
+  readonly filename: string
+  readonly contentType: string
+  readonly sizeBytes: number
+  readonly status: string
+  readonly failureReason: string | null
+  readonly downloadCount: number
+  readonly uploaderUserId: number | null
+  readonly uploaderUsername: string | null
+  readonly createdAt: Date
+}
+
+export interface AttachmentAdminFilter {
+  readonly filename?: string | undefined
+  readonly status?: string | undefined
+  readonly uploaderUserId?: number | undefined
+  readonly beforeId?: number | undefined
+  readonly offset?: number | undefined
+  readonly limit: number
+}
+
+export interface AttachmentAdminPage {
+  readonly rows: readonly AttachmentAdminRow[]
+  readonly nextBeforeId: number | null
+  /** How many attachments the filter matches, whichever page was asked for. */
+  readonly total: number
+}
+
+export interface AttachmentTotals {
+  readonly count: number
+  readonly bytes: number
+  readonly pending: number
+  readonly failed: number
+}
+
+const STATUSES = new Set(['pending', 'ready', 'failed'])
+
+export class PostgresAttachmentAdminRepository {
+  constructor(private readonly db: Database) {}
+
+  async list(filter: AttachmentAdminFilter): Promise<AttachmentAdminPage> {
+    const conditions = [sql`true`]
+
+    if (filter.filename !== undefined && filter.filename !== '') {
+      conditions.push(sql`a.filename ilike ${`%${likeFragment(filter.filename)}%`} escape '\\'`)
+    }
+    if (filter.status !== undefined && STATUSES.has(filter.status)) {
+      conditions.push(sql`a.status = ${filter.status}`)
+    }
+    if (filter.uploaderUserId !== undefined) {
+      conditions.push(sql`a.uploader_user_id = ${filter.uploaderUserId}`)
+    }
+    if (filter.beforeId !== undefined) {
+      conditions.push(sql`a.id < ${filter.beforeId}`)
+    }
+
+    const where = sql.join(conditions, sql` and `)
+
+    const [listed, counted] = await Promise.all([
+      this.db.execute(sql`
+        select a.id, a.post_id, a.filename, a.content_type, a.size_bytes, a.status,
+               a.failure_reason, a.download_count, a.uploader_user_id, a.created_at,
+               u.username as uploader_username, t.slug as thread_slug
+          from attachments a
+          left join users u on u.id = a.uploader_user_id
+          left join posts p on p.id = a.post_id
+          left join threads t on t.id = p.thread_id
+         where ${where}
+         order by a.id desc
+         limit ${filter.limit + 1} offset ${filter.offset ?? 0}
+      `),
+      this.db.execute(sql`
+        select count(*)::int as total from attachments a where ${where}
+      `),
+    ])
+
+    const rows = resultRows(listed) as Array<Record<string, unknown>>
+
+    const page = rows.slice(0, filter.limit).map(
+      (row): AttachmentAdminRow => ({
+        id: Number(row.id),
+        postId: Number(row.post_id),
+        threadSlug: row.thread_slug === null ? null : String(row.thread_slug),
+        filename: String(row.filename),
+        contentType: String(row.content_type),
+        sizeBytes: Number(row.size_bytes),
+        status: String(row.status),
+        failureReason: row.failure_reason === null ? null : String(row.failure_reason),
+        downloadCount: Number(row.download_count),
+        uploaderUserId: row.uploader_user_id === null ? null : Number(row.uploader_user_id),
+        uploaderUsername: row.uploader_username === null ? null : String(row.uploader_username),
+        createdAt: new Date(String(row.created_at)),
+      }),
+    )
+
+    const total = Number((resultRows(counted) as Array<Record<string, unknown>>)[0]?.total ?? 0)
+
+    return {
+      rows: page,
+      nextBeforeId: rows.length > filter.limit ? (page[page.length - 1]?.id ?? null) : null,
+      total,
+    }
+  }
+
+  async totals(): Promise<AttachmentTotals> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as count,
+               coalesce(sum(size_bytes), 0)::bigint as bytes,
+               count(*) filter (where status = 'pending')::int as pending,
+               count(*) filter (where status = 'failed')::int as failed
+          from attachments
+      `),
+    ) as Array<Record<string, unknown>>
+
+    const row = rows[0]
+    return {
+      count: Number(row?.count ?? 0),
+      bytes: Number(row?.bytes ?? 0),
+      pending: Number(row?.pending ?? 0),
+      failed: Number(row?.failed ?? 0),
+    }
+  }
+
+  async delete(id: number): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`
+          delete from attachments
+           where id = ${id}
+          returning storage_key, source_key, thumbnail_key
+        `),
+      ) as Array<Record<string, unknown>>
+
+      const row = rows[0]
+      if (row === undefined) return false
+
+      const keys = [row.storage_key, row.source_key, row.thumbnail_key].filter(
+        (key): key is string => typeof key === 'string' && key !== '',
+      )
+
+      for (const key of keys) {
+        await tx.execute(sql`
+          insert into attachment_orphans (storage_key) values (${key})
+          on conflict (storage_key) do nothing
+        `)
+      }
+
+      return true
+    })
+  }
+}