fix(dashboard-agent-db): backfill last_read_at so existing chats start read

The column was added nullable and every reader treats NULL as unread, so the
first load after rollout reported every pre-existing chat unread.

Author: kathiekiwi

apps/webapp/test/dashboardAgentLastReadBackfill.test.ts

@@ -0,0 +1,137 @@
+import {
+  countChatsWithUnreadWork,
+  createDashboardAgentDb,
+  type DashboardAgentDb,
+  type DashboardAgentDbClient,
+} from "@internal/dashboard-agent-db";
+import { postgresTest } from "@internal/testcontainers";
+import type { PrismaClient } from "@trigger.dev/database";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { afterEach, describe, expect } from "vitest";
+
+/**
+ * `chats.last_read_at` is nullable and every reader treats NULL as unread, so without a
+ * backfill the first load after rollout reports every pre-existing chat unread. Migration
+ * 0002 backfills it; this replays the migrations against a real Postgres to prove it does.
+ */
+
+const DRIZZLE = path.resolve(__dirname, "../../../internal-packages/dashboard-agent-db/drizzle");
+
+const MIGRATIONS = [
+  "0000_magenta_lilandra.sql",
+  "0001_slimy_living_tribunal.sql",
+  "0002_watches_and_chat_messages.sql",
+];
+
+/** The statement under test, located by shape so removing it fails rather than silently passing. */
+const BACKFILL = /^update\s+"trigger_dashboard_agent"\."chats"\s+set\s+"last_read_at"/i;
+
+function statementsOf(file: string): string[] {
+  return readFileSync(path.join(DRIZZLE, file), "utf8")
+    .split("--> statement-breakpoint")
+    .map((statement) =>
+      statement
+        .split("\n")
+        .filter((line) => !line.trimStart().startsWith("--"))
+        .join("\n")
+        .trim()
+    )
+    .filter((statement) => statement.length > 0);
+}
+
+async function run(prisma: PrismaClient, statements: string[]) {
+  for (const statement of statements) await prisma.$executeRawUnsafe(statement);
+}
+
+const SCOPE = { organizationId: "org_1", userId: "user_1" };
+
+const CREATED_AT = new Date("2026-01-01T00:00:00.000Z");
+const LAST_MESSAGE_AT = new Date("2026-02-01T00:00:00.000Z");
+/** After the last message, so the chat is genuinely read and dropping the `where` moves it back. */
+const ALREADY_READ_AT = new Date("2026-03-01T00:00:00.000Z");
+
+/** Chats as they exist before 0002 runs — no `last_read_at` column yet. */
+async function seedPreExistingChats(prisma: PrismaClient) {
+  for (const [id, lastMessageAt] of [
+    ["chat_with_messages", LAST_MESSAGE_AT],
+    ["chat_never_messaged", null],
+    ["chat_already_read", LAST_MESSAGE_AT],
+  ] as const) {
+    await prisma.$executeRawUnsafe(
+      `insert into "trigger_dashboard_agent"."chats"
+         ("id", "organization_id", "user_id", "created_at", "updated_at", "last_message_at")
+       values ($1, $2, $3, $4, $4, $5)`,
+      id,
+      SCOPE.organizationId,
+      SCOPE.userId,
+      CREATED_AT,
+      lastMessageAt
+    );
+  }
+}
+
+async function readLastReadAt(prisma: PrismaClient): Promise<Record<string, Date | null>> {
+  const rows = await prisma.$queryRawUnsafe<Array<{ id: string; last_read_at: Date | null }>>(
+    `select "id", "last_read_at" from "trigger_dashboard_agent"."chats" order by "id"`
+  );
+  return Object.fromEntries(rows.map((row) => [row.id, row.last_read_at]));
+}
+
+let agentDbClient: DashboardAgentDbClient | undefined;
+
+afterEach(async () => {
+  await agentDbClient?.close();
+  agentDbClient = undefined;
+});
+
+describe("the last_read_at backfill in migration 0002", () => {
+  postgresTest(
+    "starts pre-existing chats read, and does not overwrite a chat already read",
+    async ({ prisma, postgresContainer }) => {
+      await run(prisma, statementsOf(MIGRATIONS[0]!));
+      await run(prisma, statementsOf(MIGRATIONS[1]!));
+
+      const statements = statementsOf(MIGRATIONS[2]!);
+      const backfillAt = statements.findIndex((statement) => BACKFILL.test(statement));
+      expect(backfillAt, "0002 contains no last_read_at backfill statement").toBeGreaterThan(-1);
+
+      // Everything up to the backfill: the column exists, the chats predate it.
+      await run(prisma, statements.slice(0, backfillAt));
+      await seedPreExistingChats(prisma);
+      // A deploy that rolled the column out ahead of the backfill could already have a value.
+      await prisma.$executeRawUnsafe(
+        `update "trigger_dashboard_agent"."chats" set "last_read_at" = $1 where "id" = 'chat_already_read'`,
+        ALREADY_READ_AT
+      );
+      expect(await readLastReadAt(prisma)).toEqual({
+        chat_with_messages: null,
+        chat_never_messaged: null,
+        chat_already_read: ALREADY_READ_AT,
+      });
+
+      await run(prisma, statements.slice(backfillAt));
+
+      expect(await readLastReadAt(prisma)).toEqual({
+        // Read as of its last message: a later message still lights the dot.
+        chat_with_messages: LAST_MESSAGE_AT,
+        // Nothing was ever said in it, so it is read as of the moment it existed.
+        chat_never_messaged: CREATED_AT,
+        // Already read; the backfill must not move it back or forward.
+        chat_already_read: ALREADY_READ_AT,
+      });
+
+      agentDbClient = createDashboardAgentDb(postgresContainer.getConnectionUri(), { max: 2 });
+      const agentDb: DashboardAgentDb = agentDbClient.db;
+
+      // The user-visible claim: the launcher dot is dark on the first load after rollout.
+      expect(await countChatsWithUnreadWork(agentDb, SCOPE)).toBe(0);
+
+      // And a positive control, so a backfill that marked everything read forever would fail.
+      await prisma.$executeRawUnsafe(
+        `update "trigger_dashboard_agent"."chats" set "last_message_at" = now() where "id" = 'chat_never_messaged'`
+      );
+      expect(await countChatsWithUnreadWork(agentDb, SCOPE)).toBe(1);
+    }
+  );
+});

internal-packages/dashboard-agent-db/drizzle/0002_watches_and_chat_messages.sql

@@ -88,6 +88,9 @@ CREATE TABLE "trigger_dashboard_agent"."watches" (
 --> statement-breakpoint
 ALTER TABLE "trigger_dashboard_agent"."chats" ADD COLUMN IF NOT EXISTS "last_read_at" timestamp with time zone;
 --> statement-breakpoint
+-- Chats that predate the column start read, so only activity after this migration lights the dot.
+UPDATE "trigger_dashboard_agent"."chats" SET "last_read_at" = coalesce("last_message_at", "created_at") WHERE "last_read_at" IS NULL;
+--> statement-breakpoint
 ALTER TABLE "trigger_dashboard_agent"."chats" ADD COLUMN IF NOT EXISTS "next_message_position" integer DEFAULT 1 NOT NULL;
 --> statement-breakpoint
 CREATE INDEX "chat_messages_chat_user_role_idx" ON "trigger_dashboard_agent"."chat_messages" USING btree ("chat_id","message_id") WHERE "trigger_dashboard_agent"."chat_messages"."role" = 'user';