@meith/db 0.33.4 → 0.35.0

package/src/subscription-repo.ts

@@ -1,6 +1,6 @@
 import { sql } from 'drizzle-orm'
 
-import { PUBLIC_CONTENT } from '@meith/core'
+import { PUBLIC_CONTENT, type ThreadAudience } from '@meith/core'
 import type {
   DigestCadence,
   PendingForUser,
@@ -15,6 +15,7 @@ import type { Database } from './client'
 import { resultRows } from './result-rows'
 import { toDate } from './row-values'
 import { idList } from './sql-lists'
+import { inAudience } from './thread-audience'
 import { visibleIn } from './visibility'
 
 interface TableShape {
@@ -31,11 +32,10 @@ function shapeFor(target: SubscriptionTarget): TableShape {
 function pendingPosts(
   userId: number,
   mode: SubscriptionMode | null,
-  visibleForumIds: readonly number[] | null,
+  audience: ThreadAudience,
 ): ReturnType<typeof sql> {
   const byMode = mode === null ? sql`` : sql`and s.mode = ${mode}`
-  const visible =
-    visibleForumIds === null ? sql`` : sql`and t.forum_id in ${idList(visibleForumIds)}`
+  const visible = sql`and ${inAudience(sql`t.forum_id`, sql`t.author_user_id`, audience)}`
 
   return sql`
     select p.id as post_id, p.thread_id, t.title as thread_title, t.slug as thread_slug,
@@ -155,15 +155,15 @@ export class PostgresSubscriptionRepository implements SubscriptionRepository {
 
   async listFor(
     userId: number,
-    options: { readonly visibleForumIds: readonly number[]; readonly limit: number },
+    options: { readonly audience: ThreadAudience; readonly limit: number },
   ): Promise<readonly SubscriptionRow[]> {
-    const visible = idList(options.visibleForumIds)
+    const visibleForums = idList(options.audience.forumIds)
 
     const rows = resultRows(
       await this.db.execute(sql`
         with pending as (
           select target, target_id, count(*)::int as pending
-            from (${pendingPosts(userId, null, options.visibleForumIds)}) p
+            from (${pendingPosts(userId, null, options.audience)}) p
            group by target, target_id
         )
         select 'thread'::text as target, s.thread_id as target_id, t.title,
@@ -175,7 +175,7 @@ export class PostgresSubscriptionRepository implements SubscriptionRepository {
                  on pending.target = 'thread' and pending.target_id = s.thread_id
          where s.user_id = ${userId}
            and ${visibleIn(sql`t.visibility`, PUBLIC_CONTENT)}
-           and t.forum_id in ${visible}
+           and ${inAudience(sql`t.forum_id`, sql`t.author_user_id`, options.audience)}
 
         union all
 
@@ -186,7 +186,7 @@ export class PostgresSubscriptionRepository implements SubscriptionRepository {
           join forums f on f.id = s.forum_id
           left join pending
                  on pending.target = 'forum' and pending.target_id = s.forum_id
-         where s.user_id = ${userId} and s.forum_id in ${visible}
+         where s.user_id = ${userId} and s.forum_id in ${visibleForums}
 
          order by created_at desc, target_id desc
          limit ${options.limit}
@@ -269,12 +269,12 @@ export class PostgresSubscriptionRepository implements SubscriptionRepository {
   async pendingFor(input: {
     readonly userId: number
     readonly mode: SubscriptionMode
-    readonly visibleForumIds: readonly number[]
+    readonly audience: ThreadAudience
     readonly limit: number
   }): Promise<PendingForUser> {
     const rows = resultRows(
       await this.db.execute(sql`
-        select * from (${pendingPosts(input.userId, input.mode, input.visibleForumIds)}) p
+        select * from (${pendingPosts(input.userId, input.mode, input.audience)}) p
          order by p.post_id
          limit ${input.limit}
       `),

package/src/system-health-repo.ts

@@ -41,7 +41,7 @@ export class PostgresSystemHealthRepository {
     const rows = resultRows(
       await this.db.execute(sql`
         select key, interval_seconds, enabled, last_run_at, next_run_at,
-               consecutive_failures
+               locked_until, consecutive_failures
           from tasks order by key
       `),
     ) as Array<Record<string, unknown>>
@@ -52,6 +52,7 @@ export class PostgresSystemHealthRepository {
       enabled: row.enabled === true,
       lastRunAt: row.last_run_at === null ? null : toDate(row.last_run_at),
       nextRunAt: row.next_run_at === null ? null : toDate(row.next_run_at),
+      lockedUntil: row.locked_until === null ? null : toDate(row.locked_until),
       consecutiveFailures: Number(row.consecutive_failures),
     }))
   }

package/src/task-repo.ts

@@ -49,6 +49,20 @@ export class PostgresTaskRepository implements TaskRepository {
       })
   }
 
+  async renew(input: { taskId: string; now: Date; staleBefore: Date }): Promise<boolean> {
+    const leaseMs = input.now.getTime() - input.staleBefore.getTime()
+    const lockedUntil = new Date(input.now.getTime() + leaseMs)
+    const result = await this.db.execute(sql`
+      update tasks
+         set locked_until = ${lockedUntil}
+       where key = ${input.taskId}
+         and locked_until is not null
+         and locked_until > ${input.now}
+      returning key
+    `)
+    return resultRows(result).length === 1
+  }
+
   async claim(input: {
     taskId: string
     now: Date

package/src/thread-repo.ts

@@ -122,12 +122,19 @@ export class PostgresThreadRepository implements ThreadRepository {
       .select({
         forumId: threads.forumId,
         authorUserId: threads.authorUserId,
+        visibility: threads.visibility,
       })
       .from(threads)
       .where(eq(threads.id, threadId))
       .limit(1)
     const row = rows[0]
-    return row ? { forumId: row.forumId, authorUserId: row.authorUserId } : null
+    return row
+      ? {
+          forumId: row.forumId,
+          authorUserId: row.authorUserId,
+          visibility: row.visibility as ThreadLocation['visibility'],
+        }
+      : null
   }
 
   async findById(

package/src/user-bulk-repo.ts

@@ -358,7 +358,11 @@ export class PostgresUserBulkRepository {
     return sql.join(conditions, sql` and `)
   }
 
-  async claimMassMailChunk(massMailId: number, limit: number): Promise<MassMailChunk> {
+  async claimMassMailChunk(
+    massMailId: number,
+    limit: number,
+    enqueue: (recipients: readonly MassMailRecipient[]) => Promise<void>,
+  ): Promise<MassMailChunk> {
     return this.db.transaction(async (tx) => {
       const mails = resultRows(
         await tx.execute(sql`
@@ -393,6 +397,8 @@ export class PostgresUserBulkRepository {
       const finished = recipients.length < limit
       const cursor = recipients.at(-1)?.userId ?? after
 
+      await enqueue(recipients)
+
       await tx.execute(sql`
         update mass_mails
            set last_user_id = ${cursor},

package/src/user-merge-map.ts

@@ -15,6 +15,7 @@ export type DiscardColumn = ReassignColumn
 export const MERGE_REASSIGN: readonly ReassignColumn[] = [
   { table: 'admin_log', column: 'user_id' },
   { table: 'admin_undo_operations', column: 'actor_user_id' },
+  { table: 'backup_runs', column: 'requested_by_user_id' },
   { table: 'attachments', column: 'uploader_user_id' },
   { table: 'ban_filters', column: 'created_by_user_id' },
   { table: 'bans', column: 'banned_by_user_id' },