@meith/db 0.31.0 → 0.32.0

package/src/task-repo.ts

@@ -12,7 +12,12 @@ export class PostgresTaskRepository implements TaskRepository {
   constructor(private readonly db: Database) {}
 
   async ensureRegistered(
-    definitions: readonly { id: string; intervalSeconds: number }[],
+    definitions: readonly {
+      id: string
+      intervalSeconds: number
+      schedule?: string
+      firstRunAt?: Date
+    }[],
   ): Promise<void> {
     if (definitions.length === 0) return
 
@@ -22,15 +27,19 @@ export class PostgresTaskRepository implements TaskRepository {
         definitions.map((d) => ({
           key: d.id,
           intervalSeconds: d.intervalSeconds,
-          nextRunAt: NEVER_RUN,
+          schedule: d.schedule ?? null,
+          nextRunAt: d.firstRunAt ?? NEVER_RUN,
         })),
       )
       .onConflictDoUpdate({
         target: tasks.key,
         set: {
           intervalSeconds: sql`excluded.interval_seconds`,
+          schedule: sql`excluded.schedule`,
           nextRunAt: sql`
-            case when ${tasks.intervalSeconds} is distinct from excluded.interval_seconds
+            case when excluded.schedule is not null
+                 then ${tasks.nextRunAt}
+                 when ${tasks.intervalSeconds} is distinct from excluded.interval_seconds
                  then coalesce(${tasks.lastRunAt}, now())
                       + make_interval(secs => excluded.interval_seconds)
                  else ${tasks.nextRunAt}
@@ -79,15 +88,18 @@ export class PostgresTaskRepository implements TaskRepository {
     success: boolean
     detail?: Record<string, unknown>
     error?: string
+    nextRunAt?: Date
   }): Promise<void> {
+    const nextRunExpr =
+      input.nextRunAt === undefined
+        ? sql`${input.finishedAt}::timestamptz + make_interval(secs => interval_seconds)`
+        : sql`${input.nextRunAt}::timestamptz`
+
     await this.db.transaction(async (tx) => {
       await tx.execute(sql`
         update tasks
            set locked_until = null,
-               -- Explicit cast: an untyped bind parameter leaves Postgres
-               -- unable to resolve timestamp-plus-interval at parse time.
-               next_run_at = ${input.finishedAt}::timestamptz
-                             + make_interval(secs => interval_seconds),
+               next_run_at = ${nextRunExpr},
                consecutive_failures = ${input.success ? sql`0` : sql`consecutive_failures + 1`}
          where key = ${input.taskId}
       `)

package/src/thread-writes.ts

@@ -22,7 +22,7 @@ import type {
 import type { Database } from './client'
 import { applyCreatedContentCounters } from './content-counters'
 import { resultRows } from './result-rows'
-import { SEARCH_DOCUMENT_VERSION, searchVectorSql } from './search-repo'
+import { readSearchConfig, SEARCH_DOCUMENT_VERSION, searchVectorSql } from './search-repo'
 import { readBoardVocabulary } from './vocabulary-repo'
 
 export class PostgresThreadWriteRepository implements ThreadWriteRepository, ReplyWriteRepository {
@@ -79,6 +79,7 @@ export class PostgresThreadWriteRepository implements ThreadWriteRepository, Rep
       { source: 'post', viewer: authorRef(record.authorUserId) },
       vocabularyOptions(vocabulary),
     )
+    const searchConfig = await readSearchConfig(this.db)
 
     return this.db.transaction(async (tx) => {
       const threadRows = resultRows(
@@ -116,7 +117,7 @@ export class PostgresThreadWriteRepository implements ThreadWriteRepository, Rep
               * is_first_post true), which search-repo.test.ts pins so the
               * writer and the backfill cannot drift apart.
               */
-             ${searchVectorSql(sql`${record.title}`, sql`${record.message}`)},
+             ${searchVectorSql(searchConfig, sql`${record.title}`, sql`${record.message}`)},
              ${SEARCH_DOCUMENT_VERSION})
           returning id
         `),
@@ -145,7 +146,7 @@ export class PostgresThreadWriteRepository implements ThreadWriteRepository, Rep
       if (record.subscribe) {
         await tx.execute(sql`
           insert into thread_subscriptions (user_id, thread_id, mode, last_notified_post_id)
-          values (${record.authorUserId}, ${threadId}, 'instant', ${postId})
+          values (${record.authorUserId}, ${threadId}, ${record.subscribeMode ?? 'instant'}, ${postId})
           on conflict (user_id, thread_id) do nothing
         `)
       }
@@ -230,6 +231,7 @@ export class PostgresThreadWriteRepository implements ThreadWriteRepository, Rep
       { source: 'post', viewer: authorRef(record.authorUserId) },
       vocabularyOptions(vocabulary),
     )
+    const searchConfig = await readSearchConfig(this.db)
 
     return this.db.transaction(async (tx) => {
       const postRows = resultRows(
@@ -251,7 +253,7 @@ export class PostgresThreadWriteRepository implements ThreadWriteRepository, Rep
               * post in the thread — forty hits that are all the same thread,
               * where the opening post already stands for it.
               */
-             ${searchVectorSql(sql`${null}`, sql`${record.message}`)},
+             ${searchVectorSql(searchConfig, sql`${null}`, sql`${record.message}`)},
              ${SEARCH_DOCUMENT_VERSION})
           returning id
         `),
@@ -274,7 +276,7 @@ export class PostgresThreadWriteRepository implements ThreadWriteRepository, Rep
       if (record.subscribe) {
         await tx.execute(sql`
           insert into thread_subscriptions (user_id, thread_id, mode, last_notified_post_id)
-          values (${record.authorUserId}, ${record.threadId}, 'instant', ${postId})
+          values (${record.authorUserId}, ${record.threadId}, ${record.subscribeMode ?? 'instant'}, ${postId})
           on conflict (user_id, thread_id) do nothing
         `)
       }

package/src/upgrade-repo.ts

@@ -1,6 +1,8 @@
 import { sql } from 'drizzle-orm'
 
 import type { Database } from './client'
+import { ensurePluginDataRole } from './plugin-role'
+import { resultRows } from './result-rows'
 
 export async function readVersion(db: Database, component: string): Promise<string | null> {
   const rows = (await db.execute(sql`
@@ -49,18 +51,24 @@ export async function applyPluginMigration(
   statements: readonly string[],
 ): Promise<boolean> {
   return db.transaction(async (tx) => {
-    const claimed = (await tx.execute(sql`
-      insert into plugin_migrations (plugin_key, migration_id)
-      values (${pluginKey}, ${migrationId})
-      on conflict (plugin_key, migration_id) do nothing
-      returning migration_id
-    `)) as unknown as unknown[]
+    const claimed = resultRows(
+      await tx.execute(sql`
+        insert into plugin_migrations (plugin_key, migration_id)
+        values (${pluginKey}, ${migrationId})
+        on conflict (plugin_key, migration_id) do nothing
+        returning migration_id
+      `),
+    )
 
-    if (claimed.length === 0) return false
+    if (claimed.length === 0) {
+      await ensurePluginDataRole(tx, pluginKey)
+      return false
+    }
 
     for (const statement of statements) {
       await tx.execute(sql.raw(statement))
     }
+    await ensurePluginDataRole(tx, pluginKey)
     return true
   })
 }

package/src/user-merge-map.ts

@@ -74,6 +74,7 @@ export const ACCOUNT_CLOSURE_DISCARD: readonly DiscardColumn[] = [
   { table: 'recovery_codes', column: 'user_id' },
   { table: 'api_tokens', column: 'user_id' },
   { table: 'credential_tokens', column: 'user_id' },
+  { table: 'feed_tokens', column: 'user_id' },
   { table: 'remember_tokens', column: 'user_id' },
   { table: 'sessions', column: 'user_id' },
   { table: 'user_identities', column: 'user_id' },