@meith/db 0.30.1 → 0.32.0

package/migrations/meta/_journal.json

@@ -421,6 +421,48 @@
       "when": 1788876000000,
       "tag": "0059_member_directory_navigation",
       "breakpoints": true
+    },
+    {
+      "idx": 60,
+      "version": "7",
+      "when": 1789000000000,
+      "tag": "0060_webhook_payload_format",
+      "breakpoints": true
+    },
+    {
+      "idx": 61,
+      "version": "7",
+      "when": 1789100000000,
+      "tag": "0061_task_schedule",
+      "breakpoints": true
+    },
+    {
+      "idx": 62,
+      "version": "7",
+      "when": 1788314541634,
+      "tag": "0062_pretty_zombie",
+      "breakpoints": true
+    },
+    {
+      "idx": 63,
+      "version": "7",
+      "when": 1788327929586,
+      "tag": "0063_board_digest",
+      "breakpoints": true
+    },
+    {
+      "idx": 64,
+      "version": "7",
+      "when": 1788330549648,
+      "tag": "0064_redundant_lady_bullseye",
+      "breakpoints": true
+    },
+    {
+      "idx": 65,
+      "version": "7",
+      "when": 1788346593870,
+      "tag": "0065_serious_puff_adder",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meith/db",
-  "version": "0.30.1",
+  "version": "0.32.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -22,35 +22,36 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.7",
-    "@meith/accounts": "0.30.1",
-    "@meith/admin": "0.30.1",
-    "@meith/antispam": "0.30.1",
-    "@meith/api": "0.30.1",
-    "@meith/authorization": "0.30.1",
-    "@meith/attachments": "0.30.1",
-    "@meith/avatars": "0.30.1",
-    "@meith/core": "0.30.1",
-    "@meith/drafts": "0.30.1",
-    "@meith/events": "0.30.1",
-    "@meith/forums": "0.30.1",
-    "@meith/groups": "0.30.1",
-    "@meith/i18n": "0.30.1",
-    "@meith/markdown": "0.30.1",
-    "@meith/marketplace": "0.30.1",
-    "@meith/messages": "0.30.1",
-    "@meith/moderation": "0.30.1",
-    "@meith/notifications": "0.30.1",
-    "@meith/plugin-kit": "0.30.1",
-    "@meith/polls": "0.30.1",
-    "@meith/profile-fields": "0.30.1",
-    "@meith/relations": "0.30.1",
-    "@meith/reputation": "0.30.1",
-    "@meith/settings": "0.30.1",
-    "@meith/search": "0.30.1",
-    "@meith/signatures": "0.30.1",
-    "@meith/subscriptions": "0.30.1",
-    "@meith/tasks": "0.30.1",
-    "@meith/threads": "0.30.1"
+    "@meith/accounts": "0.32.0",
+    "@meith/admin": "0.32.0",
+    "@meith/antispam": "0.32.0",
+    "@meith/api": "0.32.0",
+    "@meith/attachments": "0.32.0",
+    "@meith/authorization": "0.32.0",
+    "@meith/avatars": "0.32.0",
+    "@meith/board-digest": "0.32.0",
+    "@meith/core": "0.32.0",
+    "@meith/drafts": "0.32.0",
+    "@meith/events": "0.32.0",
+    "@meith/forums": "0.32.0",
+    "@meith/groups": "0.32.0",
+    "@meith/i18n": "0.32.0",
+    "@meith/markdown": "0.32.0",
+    "@meith/marketplace": "0.32.0",
+    "@meith/messages": "0.32.0",
+    "@meith/moderation": "0.32.0",
+    "@meith/notifications": "0.32.0",
+    "@meith/plugin-kit": "0.32.0",
+    "@meith/polls": "0.32.0",
+    "@meith/profile-fields": "0.32.0",
+    "@meith/relations": "0.32.0",
+    "@meith/reputation": "0.32.0",
+    "@meith/search": "0.32.0",
+    "@meith/settings": "0.32.0",
+    "@meith/signatures": "0.32.0",
+    "@meith/subscriptions": "0.32.0",
+    "@meith/tasks": "0.32.0",
+    "@meith/threads": "0.32.0"
   },
   "devDependencies": {
     "drizzle-kit": "^0.31.6",

package/src/account-repos.ts

@@ -98,21 +98,38 @@ export class PostgresAccountRepository implements AccountRepository {
   }
 
   async create(input: NewAccount): Promise<AccountRecord> {
-    const rows = await this.db
-      .insert(users)
-      .values({
-        username: input.username,
-        usernameLower: input.usernameLower,
-        email: input.email,
-        emailLower: input.emailLower,
-        passwordHash: input.passwordHash,
-        passwordAlgo: input.passwordAlgo,
-        state: input.state,
-        primaryGroupId: input.primaryGroupId,
-        registrationIpPrefix: input.registrationIpPrefix ?? null,
-      })
-      .returning(ACCOUNT_COLUMNS)
-    return toAccountRecord(rows[0]!)
+    return this.db.transaction(async (tx) => {
+      const rows = await tx
+        .insert(users)
+        .values({
+          username: input.username,
+          usernameLower: input.usernameLower,
+          email: input.email,
+          emailLower: input.emailLower,
+          passwordHash: input.passwordHash,
+          passwordAlgo: input.passwordAlgo,
+          state: input.state,
+          primaryGroupId: input.primaryGroupId,
+          registrationIpPrefix: input.registrationIpPrefix ?? null,
+        })
+        .returning(ACCOUNT_COLUMNS)
+
+      const record = toAccountRecord(rows[0]!)
+
+      await tx.execute(sql`
+        insert into outbox (topic, payload)
+        values (
+          'user.registered',
+          ${JSON.stringify({
+            userId: record.id,
+            email: input.email,
+            requiresActivation: input.state === 'awaiting_activation',
+          })}::jsonb
+        )
+      `)
+
+      return record
+    })
   }
 
   async recordLastIpPrefix(userId: number, prefix: string): Promise<void> {

package/src/api-repo.ts

@@ -1,8 +1,9 @@
 import { sql } from 'drizzle-orm'
 
-import type { ApiTokenRecord, RateLimitStore, Scope } from '@meith/api'
+import type { ApiTokenRecord, RateLimitStore, Scope, WebhookFormat, WebhookTopic } from '@meith/api'
 
 import type { Database } from './client'
+import { resultRows } from './result-rows'
 
 interface TokenRow {
   id: number
@@ -182,28 +183,204 @@ export interface WebhookDeliveryRow {
   readonly secret: string
 }
 
+export interface WebhookActiveSubscription {
+  readonly id: number
+  readonly format: WebhookFormat
+}
+
+export interface WebhookSummary {
+  readonly id: number
+  readonly url: string
+  readonly topics: readonly WebhookTopic[]
+  readonly active: boolean
+  readonly format: WebhookFormat
+  readonly createdAt: Date
+  readonly delivered: number
+  readonly pending: number
+  readonly dead: number
+}
+
+export interface WebhookDeliveryLogRow {
+  readonly id: number
+  readonly deliveryId: string
+  readonly topic: string
+  readonly status: string
+  readonly attempts: number
+  readonly lastStatusCode: number | null
+  readonly lastError: string | null
+  readonly createdAt: Date
+  readonly completedAt: Date | null
+}
+
+function parseTopics(raw: unknown): readonly WebhookTopic[] {
+  return Array.isArray(raw)
+    ? (raw.filter((value) => typeof value === 'string') as WebhookTopic[])
+    : []
+}
+
+function parseFormat(raw: unknown): WebhookFormat {
+  return raw === 'discord' ? 'discord' : 'json'
+}
+
 export class PostgresWebhookRepository {
   constructor(private readonly db: Database) {}
 
   async enqueue(
+    webhookId: number,
     topic: string,
     deliveryId: string,
     payload: Record<string, unknown>,
-  ): Promise<number> {
-    const rows = (await this.db.execute(sql`
+  ): Promise<boolean> {
+    const rows = resultRows(
+      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}
+      values (${webhookId}, ${deliveryId}, ${topic}, ${JSON.stringify(payload)}::jsonb)
       on conflict (webhook_id, delivery_id) do nothing
       returning id
-    `)) as unknown as unknown[]
+    `),
+    )
 
-    return rows.length
+    return rows.length > 0
+  }
+
+  async listActiveByTopic(topic: string): Promise<readonly WebhookActiveSubscription[]> {
+    const rows = resultRows<{ id: number; format: unknown }>(
+      await this.db.execute(sql`
+      select id, format
+      from webhooks
+      where active = true and topics ? ${topic}
+      order by id
+    `),
+    )
+
+    return rows.map((row) => ({ id: Number(row.id), format: parseFormat(row.format) }))
+  }
+
+  async listAll(limit = 200): Promise<readonly WebhookSummary[]> {
+    const rows = resultRows<{
+      id: number
+      url: string
+      topics: unknown
+      active: boolean
+      format: unknown
+      created_at: Date | string
+      delivered: number | string
+      pending: number | string
+      dead: number | string
+    }>(
+      await this.db.execute(sql`
+      select w.id, w.url, w.topics, w.active, w.format, w.created_at,
+             count(d.id) filter (where d.status = 'delivered') as delivered,
+             count(d.id) filter (where d.status = 'pending') as pending,
+             count(d.id) filter (where d.status = 'dead') as dead
+      from webhooks w
+      left join webhook_deliveries d on d.webhook_id = w.id
+      group by w.id
+      order by w.created_at desc, w.id desc
+      limit ${limit}
+    `),
+    )
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      url: row.url,
+      topics: parseTopics(row.topics),
+      active: row.active,
+      format: parseFormat(row.format),
+      createdAt: new Date(row.created_at),
+      delivered: Number(row.delivered),
+      pending: Number(row.pending),
+      dead: Number(row.dead),
+    }))
+  }
+
+  async recentDeliveries(webhookId: number, limit = 20): Promise<readonly WebhookDeliveryLogRow[]> {
+    const rows = resultRows<{
+      id: number
+      delivery_id: string
+      topic: string
+      status: string
+      attempts: number
+      last_status_code: number | null
+      last_error: string | null
+      created_at: Date | string
+      completed_at: Date | string | null
+    }>(
+      await this.db.execute(sql`
+      select id, delivery_id, topic, status, attempts, last_status_code, last_error,
+             created_at, completed_at
+      from webhook_deliveries
+      where webhook_id = ${webhookId}
+      order by created_at desc, id desc
+      limit ${limit}
+    `),
+    )
+
+    return rows.map((row) => ({
+      id: Number(row.id),
+      deliveryId: row.delivery_id,
+      topic: row.topic,
+      status: row.status,
+      attempts: Number(row.attempts),
+      lastStatusCode: row.last_status_code === null ? null : Number(row.last_status_code),
+      lastError: row.last_error,
+      createdAt: new Date(row.created_at),
+      completedAt: row.completed_at === null ? null : new Date(row.completed_at),
+    }))
+  }
+
+  async create(input: {
+    readonly url: string
+    readonly secret: string
+    readonly topics: readonly WebhookTopic[]
+    readonly active: boolean
+    readonly format: WebhookFormat
+    readonly createdBy: number | null
+  }): Promise<number> {
+    const rows = resultRows<{ id: number }>(
+      await this.db.execute(sql`
+      insert into webhooks (url, secret, topics, active, format, created_by)
+      values (${input.url}, ${input.secret}, ${JSON.stringify(input.topics)}::jsonb,
+              ${input.active}, ${input.format}, ${input.createdBy})
+      returning id
+    `),
+    )
+
+    return rows[0]!.id
+  }
+
+  async setActive(id: number, active: boolean): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+      update webhooks set active = ${active}
+      where id = ${id}
+      returning id
+    `),
+    )
+    return rows.length > 0
+  }
+
+  async remove(id: number): Promise<boolean> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+      delete from webhooks where id = ${id} returning id
+    `),
+    )
+    return rows.length > 0
   }
 
   async claimDue(now: Date, limit: number): Promise<readonly WebhookDeliveryRow[]> {
-    const rows = (await this.db.execute(sql`
+    const rows = resultRows<{
+      id: number
+      webhook_id: number
+      delivery_id: string
+      topic: string
+      payload: Record<string, unknown>
+      attempts: number
+      url: string
+      secret: string
+    }>(
+      await this.db.execute(sql`
       with due as (
         select d.id
         from webhook_deliveries d
@@ -217,16 +394,8 @@ export class PostgresWebhookRepository {
       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,
@@ -265,12 +434,14 @@ export class PostgresWebhookRepository {
   }
 
   async retryDead(id: number, at: Date): Promise<boolean> {
-    const rows = (await this.db.execute(sql`
+    const rows = resultRows(
+      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-repo.ts

@@ -190,6 +190,32 @@ export class PostgresAttachmentRepository implements AttachmentRepository {
     return rows[0] === undefined ? null : toRecord(rows[0])
   }
 
+  async deleteForPost(id: number, postId: number): Promise<AttachmentRecord | null> {
+    return this.db.transaction(async (tx) => {
+      const rows = resultRows(
+        await tx.execute(sql`
+          delete from attachments
+           where id = ${id} and post_id = ${postId}
+          returning ${COLUMNS}
+        `),
+      ) as RawAttachment[]
+
+      const row = rows[0]
+      if (row === undefined) return null
+
+      const record = toRecord(row)
+      for (const key of [record.storageKey, record.sourceKey, record.thumbnailKey]) {
+        if (key === null) continue
+        await tx.execute(sql`
+          insert into attachment_orphans (storage_key) values (${key})
+          on conflict (storage_key) do nothing
+        `)
+      }
+
+      return record
+    })
+  }
+
   async deleteOrphans(before: Date, limit: number): Promise<readonly AttachmentRecord[]> {
     const rows = resultRows(
       await this.db.execute(sql`

package/src/board-digest-repo.ts

@@ -0,0 +1,45 @@
+import { sql } from 'drizzle-orm'
+
+import type { BoardDigestCadence, BoardDigestRepository, EligibleMember } from '@meith/board-digest'
+
+import type { Database } from './client'
+import { resultRows } from './result-rows'
+import { toDate } from './row-values'
+
+export class PostgresBoardDigestRepository implements BoardDigestRepository {
+  constructor(private readonly db: Database) {}
+
+  async dueMembers(input: {
+    readonly cadence: BoardDigestCadence
+    readonly dueBefore: Date
+    readonly lapsedBefore: Date
+    readonly limit: number
+  }): Promise<readonly EligibleMember[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select u.id as user_id, u.last_active_at
+          from users u
+          join notification_preferences p
+                 on p.user_id = u.id and p.kind = 'board.digest' and p.email = true
+         where u.state = 'active'
+           and u.board_digest_cadence = ${input.cadence}
+           and u.last_active_at is not null
+           and u.last_active_at < ${input.lapsedBefore}
+           and (u.board_digest_sent_at is null or u.board_digest_sent_at < ${input.dueBefore})
+         order by u.id
+         limit ${input.limit}
+      `),
+    ) as Array<{ user_id: number; last_active_at: string | Date }>
+
+    return rows.map((row) => ({
+      userId: Number(row.user_id),
+      lastActiveAt: toDate(row.last_active_at),
+    }))
+  }
+
+  async recordDigestRun(input: { readonly userId: number; readonly at: Date }): Promise<void> {
+    await this.db.execute(sql`
+      update users set board_digest_sent_at = ${input.at} where id = ${input.userId}
+    `)
+  }
+}

package/src/content-counters.ts

@@ -77,6 +77,20 @@ export async function applyCreatedContentCounters(
       })}::jsonb
     )
   `)
+
+  if (content.isNewThread) {
+    await tx.execute(sql`
+      insert into outbox (topic, payload)
+      values (
+        'thread.created',
+        ${JSON.stringify({
+          threadId: content.threadId,
+          forumId: content.forumId,
+          authorId: content.authorId,
+        })}::jsonb
+      )
+    `)
+  }
 }
 
 export async function rollUpAncestorCounters(db: Database, postId: number): Promise<boolean> {

package/src/discovery-repo.ts

@@ -79,10 +79,31 @@ export class PostgresDiscoveryRepository {
     )
   }
 
+  async unread(
+    userId: number,
+    query: DiscoveryQuery,
+    scope: DiscoveryScope,
+  ): Promise<DiscoveryPage> {
+    return this.page(
+      [
+        sql`t.last_post_id is not null`,
+        sql`(tr.last_read_post_id is null or t.last_post_id > tr.last_read_post_id)`,
+        sql`(fr.read_at is null or t.last_post_at > fr.read_at)`,
+      ],
+      query,
+      scope,
+      [
+        sql`left join threads_read tr on tr.thread_id = t.id and tr.user_id = ${userId}`,
+        sql`left join forums_read fr on fr.forum_id = t.forum_id and fr.user_id = ${userId}`,
+      ],
+    )
+  }
+
   private async page(
     conditions: readonly SQL[],
     query: DiscoveryQuery,
     scope: DiscoveryScope,
+    joins: readonly SQL[] = [],
   ): Promise<DiscoveryPage> {
     if (audienceIsEmpty(scope)) return { rows: [], nextCursor: null }
 
@@ -107,6 +128,7 @@ export class PostgresDiscoveryRepository {
                t.reply_count, t.last_post_at, t.last_post_username
           from threads t
           join forums f on f.id = t.forum_id
+          ${sql.join([...joins], sql` `)}
          where ${sql.join(where, sql` and `)}
          order by t.last_post_at desc, t.id desc
          limit ${query.limit}

package/src/draft-repo.ts

@@ -1,6 +1,6 @@
 import { sql } from 'drizzle-orm'
 
-import type { Draft, DraftRepository } from '@meith/drafts'
+import type { Draft, DraftRepository, DraftSummary } from '@meith/drafts'
 import { BodyFormat, sourceAsMarkdown } from '@meith/markdown'
 
 import type { Database } from './client'
@@ -56,4 +56,43 @@ export class PostgresDraftRepository implements DraftRepository {
        and thread_id is not distinct from ${threadId}
     `)
   }
+
+  async listByUser(userId: number): Promise<readonly DraftSummary[]> {
+    const rows = resultRows(
+      await this.db.execute(sql`
+        select d.forum_id, f.title as forum_title, f.slug as forum_slug,
+               d.thread_id, t.title as thread_title, t.slug as thread_slug,
+               d.title, d.message, d.body_format, d.updated_at
+          from post_drafts d
+          join forums f on f.id = d.forum_id
+          left join threads t on t.id = d.thread_id
+         where d.user_id = ${userId}
+           and (d.thread_id is null or t.id is not null)
+         order by d.updated_at desc
+      `),
+    ) as Array<{
+      forum_id: number
+      forum_title: string
+      forum_slug: string
+      thread_id: number | null
+      thread_title: string | null
+      thread_slug: string | null
+      title: string
+      message: string
+      body_format: number
+      updated_at: Date | string
+    }>
+
+    return rows.map((row) => ({
+      forumId: Number(row.forum_id),
+      forumTitle: row.forum_title,
+      forumSlug: row.forum_slug,
+      threadId: row.thread_id === null ? null : Number(row.thread_id),
+      threadTitle: row.thread_title,
+      threadSlug: row.thread_slug,
+      title: row.title,
+      message: sourceAsMarkdown(row.message, Number(row.body_format)),
+      updatedAt: new Date(row.updated_at),
+    }))
+  }
 }