@meith/db 0.16.0

package/src/report-repo.ts

@@ -0,0 +1,349 @@
+import { sql } from 'drizzle-orm'
+
+import { PUBLIC_CONTENT } from '@meith/core'
+import type {
+  NewReport,
+  ReportEvent,
+  ReportPage,
+  ReportRepository,
+  ReportRow,
+  ReportScope,
+  ReportTarget,
+  ReportTargetKind,
+} from '@meith/moderation'
+
+import type { Database } from './client'
+import { decodeCursor, encodeCursor } from './cursor'
+import { resultRows } from './result-rows'
+import { threads } from './schema'
+import { idList } from './sql-lists'
+import { logModeratorAction } from './thread-counters'
+import { visibleIn } from './visibility'
+
+interface RawReport {
+  id: number
+  target_kind: ReportTargetKind
+  target_id: number
+  forum_id: number | null
+  thread_id: number | null
+  target_label: string
+  reporter_user_id: number | null
+  reporter_username: string | null
+  reason: string
+  status: ReportRow['status']
+  assigned_to_user_id: number | null
+  assigned_username: string | null
+  created_at: Date
+}
+
+function toReport(row: RawReport): ReportRow {
+  return {
+    id: Number(row.id),
+    kind: row.target_kind,
+    targetId: Number(row.target_id),
+    forumId: row.forum_id === null ? null : Number(row.forum_id),
+    threadId: row.thread_id === null ? null : Number(row.thread_id),
+    targetLabel: row.target_label,
+    reporterUserId: row.reporter_user_id === null ? null : Number(row.reporter_user_id),
+    reporterUsername: row.reporter_username,
+    reason: row.reason,
+    status: row.status,
+    assignedToUserId: row.assigned_to_user_id === null ? null : Number(row.assigned_to_user_id),
+    assignedToUsername: row.assigned_username,
+    createdAt: new Date(row.created_at),
+  }
+}
+
+const SELECT_REPORT = sql`
+  select r.id, r.target_kind, r.target_id, r.forum_id, r.thread_id, r.target_label,
+         r.reporter_user_id, reporter.username as reporter_username,
+         r.reason, r.status, r.assigned_to_user_id,
+         assignee.username as assigned_username, r.created_at
+    from reports r
+    left join users reporter on reporter.id = r.reporter_user_id
+    left join users assignee on assignee.id = r.assigned_to_user_id
+`
+
+export class PostgresReportRepository implements ReportRepository {
+  constructor(private readonly db: Database) {}
+
+  async resolveTarget(
+    kind: ReportTargetKind,
+    id: number,
+    reporterUserId: number,
+  ): Promise<ReportTarget | null> {
+    if (kind === 'private_message') {
+      const rows = resultRows(
+        await this.db.execute(sql`
+          select m.id, m.subject
+            from private_messages m
+            join private_message_copies c
+              on c.message_id = m.id and c.owner_user_id = ${reporterUserId}
+           where m.id = ${id}
+        `),
+      ) as Array<{ id: number; subject: string }>
+      const row = rows[0]
+      return row === undefined
+        ? null
+        : {
+            kind,
+            id: Number(row.id),
+            forumId: null,
+            threadId: null,
+            threadAuthorUserId: null,
+            label: row.subject,
+          }
+    }
+
+    if (kind === 'user') {
+      const rows = resultRows(
+        await this.db.execute(sql`
+          select id, username from users where id = ${id} and deleted_at is null
+        `),
+      ) as Array<{ id: number; username: string }>
+      const row = rows[0]
+      return row === undefined
+        ? null
+        : {
+            kind,
+            id: Number(row.id),
+            forumId: null,
+            threadId: null,
+            threadAuthorUserId: null,
+            label: row.username,
+          }
+    }
+
+    if (kind === 'thread') {
+      const rows = resultRows(
+        await this.db.execute(sql`
+          select id, forum_id, author_user_id, title from threads
+           where id = ${id} and ${visibleIn(threads.visibility, PUBLIC_CONTENT)}
+        `),
+      ) as Array<{
+        id: number
+        forum_id: number
+        author_user_id: number | null
+        title: string
+      }>
+      const row = rows[0]
+      return row === undefined
+        ? null
+        : {
+            kind,
+            id: Number(row.id),
+            forumId: Number(row.forum_id),
+            threadId: Number(row.id),
+            threadAuthorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+            label: row.title,
+          }
+    }
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select p.id, p.forum_id, p.thread_id, t.author_user_id, t.title
+          from posts p
+          join threads t on t.id = p.thread_id
+         where p.id = ${id}
+           and ${visibleIn(sql`p.visibility`, PUBLIC_CONTENT)}
+           and ${visibleIn(sql`t.visibility`, PUBLIC_CONTENT)}
+      `),
+    ) as Array<{
+      id: number
+      forum_id: number
+      thread_id: number
+      author_user_id: number | null
+      title: string
+    }>
+    const row = rows[0]
+    return row === undefined
+      ? null
+      : {
+          kind,
+          id: Number(row.id),
+          forumId: Number(row.forum_id),
+          threadId: Number(row.thread_id),
+          threadAuthorUserId: row.author_user_id === null ? null : Number(row.author_user_id),
+          label: row.title,
+        }
+  }
+
+  async open(report: NewReport): Promise<number | null> {
+    return this.db.transaction(async (tx) => {
+      const inserted = resultRows(
+        await tx.execute(sql`
+          insert into reports
+            (target_kind, target_id, forum_id, thread_id, target_label,
+             reporter_user_id, reason, status, created_at, updated_at)
+          values
+            (${report.target.kind}, ${report.target.id}, ${report.target.forumId},
+             ${report.target.threadId}, ${report.target.label},
+             ${report.reporterUserId}, ${report.reason}, 'open',
+             ${report.at}, ${report.at})
+          on conflict do nothing
+          returning id
+        `),
+      ) as Array<{ id: number }>
+
+      const row = inserted[0]
+      if (!row) return null
+
+      await tx.execute(sql`
+        insert into report_events (report_id, actor_user_id, kind, created_at)
+        values (${row.id}, ${report.reporterUserId}, 'opened', ${report.at})
+      `)
+      return Number(row.id)
+    })
+  }
+
+  private scopePredicate(scope: ReportScope): ReturnType<typeof sql> {
+    const byForum = sql`r.forum_id in ${idList(scope.forumIds)}`
+    return scope.global ? sql`(${byForum} or r.forum_id is null)` : byForum
+  }
+
+  async listOpen(
+    scope: ReportScope,
+    options: {
+      readonly limit: number
+      readonly after?: string
+      readonly offset?: number
+    },
+  ): Promise<ReportPage> {
+    const cursor = options.after === undefined ? null : decodeCursor(options.after)
+    const after = cursor ? sql`and (r.created_at, r.id) > (${cursor.at}, ${cursor.id})` : sql``
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        ${SELECT_REPORT}
+         where r.status = 'open' and ${this.scopePredicate(scope)} ${after}
+         order by r.created_at, r.id
+         limit ${options.limit + 1} offset ${options.offset ?? 0}
+      `),
+    ) as RawReport[]
+
+    const page = rows.slice(0, options.limit).map(toReport)
+    const last = page.at(-1)
+    return rows.length > options.limit && last
+      ? { rows: page, nextCursor: encodeCursor(last.createdAt, last.id) }
+      : { rows: page }
+  }
+
+  async countOpen(scope: ReportScope): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as open from reports r
+         where r.status = 'open' and ${this.scopePredicate(scope)}
+      `),
+    ) as Array<{ open: number }>
+    return Number(rows[0]?.open ?? 0)
+  }
+
+  async find(id: number): Promise<{ report: ReportRow; events: readonly ReportEvent[] } | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`${SELECT_REPORT} where r.id = ${id}`),
+    ) as RawReport[]
+    const row = rows[0]
+    if (!row) return null
+
+    const events = resultRows(
+      await this.db.execute(sql`
+        select e.id, e.kind, e.actor_user_id, u.username as actor_username,
+               e.note, e.created_at
+          from report_events e
+          left join users u on u.id = e.actor_user_id
+         where e.report_id = ${id}
+         order by e.created_at, e.id
+      `),
+    ) as Array<{
+      id: number
+      kind: ReportEvent['kind']
+      actor_user_id: number | null
+      actor_username: string | null
+      note: string | null
+      created_at: Date
+    }>
+
+    return {
+      report: toReport(row),
+      events: events.map((event) => ({
+        id: Number(event.id),
+        kind: event.kind,
+        actorUserId: event.actor_user_id === null ? null : Number(event.actor_user_id),
+        actorUsername: event.actor_username,
+        note: event.note,
+        createdAt: new Date(event.created_at),
+      })),
+    }
+  }
+
+  async assign(input: {
+    readonly reportId: number
+    readonly toUserId: number | null
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const moved = resultRows(
+        await tx.execute(sql`
+          update reports
+             set assigned_to_user_id = ${input.toUserId}, updated_at = ${input.at}
+           where id = ${input.reportId} and status = 'open'
+           returning id
+        `),
+      ) as Array<{ id: number }>
+      if (moved.length === 0) return false
+
+      await tx.execute(sql`
+        insert into report_events (report_id, actor_user_id, kind, created_at)
+        values (
+          ${input.reportId}, ${input.actorUserId},
+          ${input.toUserId === null ? 'unassigned' : 'assigned'}, ${input.at}
+        )
+      `)
+      return true
+    })
+  }
+
+  async close(input: {
+    readonly reportId: number
+    readonly status: 'resolved' | 'rejected'
+    readonly note: string | null
+    readonly actorUserId: number
+    readonly at: Date
+  }): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const moved = resultRows(
+        await tx.execute(sql`
+          update reports
+             set status = ${input.status},
+                 resolved_by_user_id = ${input.actorUserId},
+                 resolved_at = ${input.at},
+                 updated_at = ${input.at}
+           where id = ${input.reportId} and status = 'open'
+           returning id, forum_id
+        `),
+      ) as Array<{ id: number; forum_id: number | null }>
+      const row = moved[0]
+      if (!row) return false
+
+      await tx.execute(sql`
+        insert into report_events (report_id, actor_user_id, kind, note, created_at)
+        values (${input.reportId}, ${input.actorUserId}, ${input.status},
+                ${input.note}, ${input.at})
+      `)
+
+      const forumId = row.forum_id === null ? null : Number(row.forum_id)
+      await logModeratorAction(
+        tx,
+        input.status === 'resolved' ? 'report.resolve' : 'report.reject',
+        input.actorUserId,
+        {
+          reportId: input.reportId,
+          ...(forumId === null ? {} : { forumId, forumIds: [forumId] }),
+        },
+        input.at,
+      )
+      return true
+    })
+  }
+}

package/src/reputation-repo.ts

@@ -0,0 +1,295 @@
+import type { SQLWrapper } from 'drizzle-orm'
+import { sql } from 'drizzle-orm'
+
+import type {
+  ReputationRepository,
+  ReputationRow,
+  ReputationSummary,
+  ReputationWriteResult,
+} from '@meith/reputation'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+
+interface RawRow {
+  id: number
+  user_id: number
+  given_by_user_id: number | null
+  given_by_username: string | null
+  post_id: number | null
+  thread_id: number | null
+  points: number
+  comment: string
+  created_at: string | Date
+  updated_at: string | Date
+}
+
+function toRow(row: RawRow): ReputationRow {
+  return {
+    id: Number(row.id),
+    userId: Number(row.user_id),
+    givenByUserId: row.given_by_user_id === null ? null : Number(row.given_by_user_id),
+    givenByUsername: row.given_by_username,
+    postId: row.post_id === null ? null : Number(row.post_id),
+    threadId: row.thread_id === null ? null : Number(row.thread_id),
+    points: Number(row.points),
+    comment: row.comment,
+    createdAt: toDate(row.created_at),
+    updatedAt: toDate(row.updated_at),
+  }
+}
+
+const SELECT_ROW = sql`
+  select r.id, r.user_id, r.given_by_user_id, r.post_id, r.points, r.comment,
+         r.created_at, r.updated_at, u.username as given_by_username,
+         p.thread_id
+    from reputation r
+    left join users u on u.id = r.given_by_user_id
+    /* For the history's link. Left, because a profile rating has no post and a
+       rated post may since have been hard-deleted. */
+    left join posts p on p.id = r.post_id
+`
+
+interface ReputationTransaction {
+  execute(query: SQLWrapper): Promise<unknown>
+}
+
+export async function recountReputation(
+  tx: ReputationTransaction,
+  userIds: readonly number[],
+): Promise<void> {
+  if (userIds.length === 0) return
+
+  await tx.execute(sql`
+    update users u
+       set reputation = coalesce(
+             (select sum(r.points)::int from reputation r where r.user_id = u.id), 0)
+     where u.id in ${sql`(${sql.join(
+       userIds.map((id) => sql`${id}`),
+       sql`, `,
+     )})`}
+  `)
+}
+
+export class PostgresReputationRepository implements ReputationRepository {
+  constructor(private readonly db: Database) {}
+
+  async give(input: {
+    readonly userId: number
+    readonly givenByUserId: number
+    readonly postId: number | null
+    readonly points: number
+    readonly comment: string
+    readonly maxPerDay: number
+    readonly at: Date
+  }): Promise<ReputationWriteResult> {
+    return this.db.transaction(async (tx) => {
+      if (input.maxPerDay > 0) {
+        const startOfDay = new Date(
+          Date.UTC(input.at.getUTCFullYear(), input.at.getUTCMonth(), input.at.getUTCDate()),
+        )
+
+        const counted = resultRows(
+          await tx.execute(sql`
+            select count(*)::int as n
+              from reputation
+             where given_by_user_id = ${input.givenByUserId}
+               and created_at >= ${startOfDay}
+          `),
+        ) as Array<{ n: number }>
+
+        const already = Number(counted[0]?.n ?? 0)
+
+        const existing = resultRows(
+          await tx.execute(sql`
+            select id from reputation
+             where given_by_user_id = ${input.givenByUserId}
+               and user_id = ${input.userId}
+               and post_id is not distinct from ${input.postId}
+          `),
+        ) as Array<{ id: number }>
+
+        if (existing.length === 0 && already >= input.maxPerDay) return 'daily-limit'
+      }
+
+      if (input.postId === null) {
+        await tx.execute(sql`
+          insert into reputation
+                 (user_id, given_by_user_id, post_id, points, comment, created_at, updated_at)
+          values (${input.userId}, ${input.givenByUserId}, null, ${input.points},
+                  ${input.comment}, ${input.at}, ${input.at})
+              on conflict (given_by_user_id, user_id) where post_id is null
+              do update set points = excluded.points,
+                            comment = excluded.comment,
+                            updated_at = excluded.updated_at
+        `)
+      } else {
+        const written = resultRows(
+          await tx.execute(sql`
+            insert into reputation
+                   (user_id, given_by_user_id, post_id, points, comment, created_at, updated_at)
+            select ${input.userId}, ${input.givenByUserId}, p.id, ${input.points},
+                   ${input.comment}, ${input.at}, ${input.at}
+              from posts p
+             where p.id = ${input.postId}
+               and p.author_user_id = ${input.userId}
+                on conflict (given_by_user_id, post_id) where post_id is not null
+                do update set points = excluded.points,
+                              comment = excluded.comment,
+                              updated_at = excluded.updated_at
+            returning id
+          `),
+        )
+        if (written.length === 0) return 'invalid-post'
+      }
+
+      await recountReputation(tx, [input.userId])
+      return 'written'
+    })
+  }
+
+  async withdraw(input: {
+    readonly ratingId: number
+    readonly givenByUserId: number
+  }): Promise<boolean> {
+    return this.db.transaction(async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`
+          delete from reputation
+           where id = ${input.ratingId} and given_by_user_id = ${input.givenByUserId}
+          returning user_id
+        `),
+      ) as Array<{ user_id: number }>
+
+      const row = rows[0]
+      if (row === undefined) return false
+
+      await recountReputation(tx, [Number(row.user_id)])
+      return true
+    })
+  }
+
+  async list(input: {
+    readonly userId: number
+    readonly limit: number
+    readonly before?: number | undefined
+  }): Promise<readonly ReputationRow[]> {
+    const before = input.before === undefined ? sql`` : sql`and r.id < ${input.before}`
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        ${SELECT_ROW}
+         where r.user_id = ${input.userId} ${before}
+         order by r.id desc
+         limit ${input.limit}
+      `),
+    ) as RawRow[]
+
+    return rows.map(toRow)
+  }
+
+  async summary(userId: number): Promise<ReputationSummary> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select coalesce(sum(points), 0)::int              as total,
+               count(*) filter (where points > 0)::int    as positive,
+               count(*) filter (where points = 0)::int    as neutral,
+               count(*) filter (where points < 0)::int    as negative
+          from reputation
+         where user_id = ${userId}
+      `),
+    ) as Array<{ total: number; positive: number; neutral: number; negative: number }>
+
+    const row = rows[0]
+    return {
+      total: Number(row?.total ?? 0),
+      positive: Number(row?.positive ?? 0),
+      neutral: Number(row?.neutral ?? 0),
+      negative: Number(row?.negative ?? 0),
+    }
+  }
+
+  async existing(input: {
+    readonly givenByUserId: number
+    readonly userId: number
+    readonly postId: number | null
+  }): Promise<ReputationRow | null> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        ${SELECT_ROW}
+         where r.given_by_user_id = ${input.givenByUserId}
+           and r.user_id = ${input.userId}
+           /* "is not distinct from" so a null post id matches a null one:
+              plain equality is never true against NULL, which would make every
+              profile rating look like a new one. */
+           and r.post_id is not distinct from ${input.postId}
+      `),
+    ) as RawRow[]
+
+    return rows[0] === undefined ? null : toRow(rows[0])
+  }
+
+  async existingForPosts(input: {
+    readonly givenByUserId: number
+    readonly postIds: readonly number[]
+  }): Promise<ReadonlyMap<number, ReputationRow>> {
+    if (input.postIds.length === 0) return new Map()
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        ${SELECT_ROW}
+         where r.given_by_user_id = ${input.givenByUserId}
+           and r.post_id in ${sql`(${sql.join(
+             input.postIds.map((id) => sql`${id}`),
+             sql`, `,
+           )})`}
+      `),
+    ) as RawRow[]
+
+    return new Map(
+      rows.map(toRow).flatMap((row) => (row.postId === null ? [] : [[row.postId, row] as const])),
+    )
+  }
+
+  async thanksForPosts(postIds: readonly number[]): Promise<ReadonlyMap<number, number>> {
+    if (postIds.length === 0) return new Map()
+
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select post_id, count(*)::int as n
+          from reputation
+         where points > 0
+           and post_id in ${sql`(${sql.join(
+             postIds.map((id) => sql`${id}`),
+             sql`, `,
+           )})`}
+         group by post_id
+      `),
+    ) as Array<{ post_id: number; n: number }>
+
+    return new Map(rows.map((row) => [Number(row.post_id), Number(row.n)]))
+  }
+
+  async givenSince(givenByUserId: number, since: Date): Promise<number> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select count(*)::int as n
+          from reputation
+         where given_by_user_id = ${givenByUserId} and created_at >= ${since}
+      `),
+    ) as Array<{ n: number }>
+
+    return Number(rows[0]?.n ?? 0)
+  }
+
+  async recount(userId: number): Promise<number> {
+    await recountReputation(this.db, [userId])
+
+    const rows = resultRows(
+      await this.db.execute(sql`select reputation from users where id = ${userId}`),
+    ) as Array<{ reputation: number }>
+
+    return Number(rows[0]?.reputation ?? 0)
+  }
+}

package/src/result-rows.ts

@@ -0,0 +1,13 @@
+export function resultRows<T = Record<string, unknown>>(result: unknown): T[] {
+  if (Array.isArray(result)) return result as T[]
+
+  if (
+    typeof result === 'object' &&
+    result !== null &&
+    Array.isArray((result as { rows?: unknown }).rows)
+  ) {
+    return (result as { rows: T[] }).rows
+  }
+
+  return []
+}

package/src/row-values.ts

@@ -0,0 +1,7 @@
+export function toDate(value: unknown): Date {
+  return value instanceof Date ? value : new Date(String(value))
+}
+
+export function toNullableDate(value: unknown): Date | null {
+  return value === null || value === undefined ? null : toDate(value)
+}