@jant/core 0.6.15 → 0.6.16

package/src/db/__tests__/backfill-thread-activity.test.ts

@@ -0,0 +1,234 @@
+/**
+ * Executes the real 0005 backfill SQL against legacy-shaped rows.
+ *
+ * The backfill runs on user data through `jant migrate`, and the same file is
+ * executed on both SQLite and Postgres, so it has to be portable and safe to
+ * rerun. These tests cover the SQLite side; the SQL avoids dialect-specific
+ * syntax (no `UPDATE ... FROM`, only correlated subqueries and TRUE/FALSE
+ * literals, which both engines accept).
+ */
+
+import { readFileSync } from "fs";
+import { resolve } from "path";
+import type BetterSqlite3 from "better-sqlite3";
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
+
+const BACKFILL_SQL = readFileSync(
+  resolve(
+    import.meta.dirname,
+    "../backfills/0005_split_thread_activity_from_quiet_replies.sql",
+  ),
+  "utf-8",
+);
+
+interface RootRow {
+  quiet_reply: number;
+  last_activity_at: number | null;
+  thread_updated_at: number | null;
+}
+
+describe("0005 backfill — split thread activity from quiet replies", () => {
+  let sqlite: BetterSqlite3.Database;
+
+  function runBackfill() {
+    sqlite.exec(BACKFILL_SQL);
+  }
+
+  /** Insert a post row the way the pre-0031 schema would have left it. */
+  function insertLegacyPost(row: {
+    id: string;
+    threadId: string;
+    replyToId?: string | null;
+    publishedAt: number | null;
+    lastActivityAt: number | null;
+    status?: string;
+  }) {
+    sqlite
+      .prepare(
+        `INSERT INTO post (
+           id, site_id, format, status, visibility, thread_id, reply_to_id,
+           published_at, last_activity_at, created_at, updated_at
+         ) VALUES (?, ?, 'note', ?, 'public', ?, ?, ?, ?, ?, ?)`,
+      )
+      .run(
+        row.id,
+        DEFAULT_TEST_SITE_ID,
+        row.status ?? "published",
+        row.threadId,
+        row.replyToId ?? null,
+        row.publishedAt,
+        row.lastActivityAt,
+        row.publishedAt ?? 0,
+        row.publishedAt ?? 0,
+      );
+  }
+
+  function readPost(id: string): RootRow {
+    return sqlite
+      .prepare(
+        `SELECT quiet_reply, last_activity_at, thread_updated_at
+         FROM post WHERE id = ?`,
+      )
+      .get(id) as RootRow;
+  }
+
+  beforeEach(() => {
+    sqlite = createTestDatabase().sqlite;
+  });
+
+  it("recovers a quiet reply from the gap it left behind", () => {
+    // A reply sitting later than the root's recorded activity can only have
+    // gotten there by skipping the bump — the signature of a quiet reply.
+    insertLegacyPost({
+      id: "pst_root",
+      threadId: "pst_root",
+      publishedAt: 1000,
+      lastActivityAt: 1000,
+    });
+    insertLegacyPost({
+      id: "pst_quiet",
+      threadId: "pst_root",
+      replyToId: "pst_root",
+      publishedAt: 3000,
+      lastActivityAt: 3000,
+    });
+
+    runBackfill();
+
+    expect(readPost("pst_quiet").quiet_reply).toBe(1);
+    const root = readPost("pst_root");
+    expect(root.last_activity_at).toBe(1000);
+    expect(root.thread_updated_at).toBe(3000);
+  });
+
+  it("leaves announced replies alone", () => {
+    insertLegacyPost({
+      id: "pst_root2",
+      threadId: "pst_root2",
+      publishedAt: 1000,
+      lastActivityAt: 2000,
+    });
+    insertLegacyPost({
+      id: "pst_reply2",
+      threadId: "pst_root2",
+      replyToId: "pst_root2",
+      publishedAt: 2000,
+      lastActivityAt: 2000,
+    });
+
+    runBackfill();
+
+    expect(readPost("pst_reply2").quiet_reply).toBe(0);
+    const root = readPost("pst_root2");
+    expect(root.last_activity_at).toBe(2000);
+    expect(root.thread_updated_at).toBe(2000);
+  });
+
+  it("ignores drafts when computing both timestamps", () => {
+    insertLegacyPost({
+      id: "pst_root3",
+      threadId: "pst_root3",
+      publishedAt: 1000,
+      lastActivityAt: 1000,
+    });
+    insertLegacyPost({
+      id: "pst_draft3",
+      threadId: "pst_root3",
+      replyToId: "pst_root3",
+      publishedAt: null,
+      lastActivityAt: null,
+      status: "draft",
+    });
+
+    runBackfill();
+
+    expect(readPost("pst_draft3").quiet_reply).toBe(0);
+    const root = readPost("pst_root3");
+    expect(root.last_activity_at).toBe(1000);
+    expect(root.thread_updated_at).toBe(1000);
+  });
+
+  it("keeps a fully unpublished thread's existing last_activity_at", () => {
+    insertLegacyPost({
+      id: "pst_root4",
+      threadId: "pst_root4",
+      publishedAt: null,
+      lastActivityAt: 500,
+      status: "draft",
+    });
+
+    runBackfill();
+
+    const root = readPost("pst_root4");
+    expect(root.last_activity_at).toBe(500);
+    expect(root.thread_updated_at).toBeNull();
+  });
+
+  it("is idempotent", () => {
+    insertLegacyPost({
+      id: "pst_root5",
+      threadId: "pst_root5",
+      publishedAt: 1000,
+      lastActivityAt: 1000,
+    });
+    insertLegacyPost({
+      id: "pst_quiet5",
+      threadId: "pst_root5",
+      replyToId: "pst_root5",
+      publishedAt: 3000,
+      lastActivityAt: 3000,
+    });
+    insertLegacyPost({
+      id: "pst_loud5",
+      threadId: "pst_root5",
+      replyToId: "pst_root5",
+      publishedAt: 900,
+      lastActivityAt: 900,
+    });
+
+    runBackfill();
+    const first = readPost("pst_root5");
+    runBackfill();
+    runBackfill();
+    const third = readPost("pst_root5");
+
+    expect(third).toEqual(first);
+    expect(first.last_activity_at).toBe(1000);
+    expect(first.thread_updated_at).toBe(3000);
+    expect(readPost("pst_quiet5").quiet_reply).toBe(1);
+    expect(readPost("pst_loud5").quiet_reply).toBe(0);
+  });
+
+  it("scopes recovery to the reply's own thread", () => {
+    insertLegacyPost({
+      id: "pst_a",
+      threadId: "pst_a",
+      publishedAt: 5000,
+      lastActivityAt: 5000,
+    });
+    insertLegacyPost({
+      id: "pst_b",
+      threadId: "pst_b",
+      publishedAt: 1000,
+      lastActivityAt: 1000,
+    });
+    // Later than thread A's activity, but it belongs to thread B.
+    insertLegacyPost({
+      id: "pst_b_reply",
+      threadId: "pst_b",
+      replyToId: "pst_b",
+      publishedAt: 2000,
+      lastActivityAt: 2000,
+    });
+
+    runBackfill();
+
+    expect(readPost("pst_b_reply").quiet_reply).toBe(1);
+    expect(readPost("pst_b").last_activity_at).toBe(1000);
+    expect(readPost("pst_a").last_activity_at).toBe(5000);
+  });
+});

package/src/db/__tests__/thread-activity.test.ts

@@ -0,0 +1,113 @@
+import { and, eq, sql } from "drizzle-orm";
+import { describe, expect, it } from "vitest";
+import {
+  createTestDatabase,
+  DEFAULT_TEST_SITE_ID,
+} from "../../__tests__/helpers/db.js";
+import { posts, threadCollections } from "../schema.js";
+import {
+  buildRootActivityExpr,
+  getRootActivityAt,
+  rootActivityColumns,
+} from "../thread-activity.js";
+
+/**
+ * The SQL assertions here look pedantic, but they guard a failure mode that
+ * produces no error and no obviously wrong output: Drizzle omits the table
+ * qualifier on interpolated columns in a single-table projection, so a
+ * correlated subquery silently binds to its own alias instead of the outer
+ * row. That is why the subquery flavor takes raw fragments.
+ */
+describe("thread activity definition", () => {
+  const normalize = (value: string) => value.replace(/\s+/g, " ");
+
+  it("prefers last activity, then publication, then the row's own write", () => {
+    expect(
+      getRootActivityAt({
+        lastActivityAt: 300,
+        publishedAt: 200,
+        updatedAt: 100,
+      }),
+    ).toBe(300);
+    expect(
+      getRootActivityAt({
+        lastActivityAt: null,
+        publishedAt: 200,
+        updatedAt: 100,
+      }),
+    ).toBe(200);
+    expect(
+      getRootActivityAt({
+        lastActivityAt: null,
+        publishedAt: null,
+        updatedAt: 100,
+      }),
+    ).toBe(100);
+  });
+
+  it("never falls back to a plain edit when real activity exists", () => {
+    // An edited root keeps its activity timestamp — the whole point.
+    expect(
+      getRootActivityAt({
+        lastActivityAt: 1000,
+        publishedAt: 1000,
+        updatedAt: 9999,
+      }),
+    ).toBe(1000);
+  });
+
+  it("qualifies the subquery flavor against the root alias", () => {
+    const { db } = createTestDatabase();
+    const expr = sql<number>`(
+      SELECT ${buildRootActivityExpr(rootActivityColumns("root"))}
+      FROM post AS root
+      WHERE root.site_id = ${DEFAULT_TEST_SITE_ID}
+        AND root.id = ${posts.threadId}
+    )`.as("activity_at");
+
+    const generated = normalize(
+      (db as never as { select: (fields: unknown) => never })
+        .select({ threadId: posts.threadId, activityAt: expr })
+        // The join is what makes Drizzle qualify `posts.threadId` below.
+        .from(posts)
+        .innerJoin(
+          threadCollections,
+          and(
+            eq(threadCollections.siteId, posts.siteId),
+            eq(threadCollections.threadId, posts.threadId),
+          ),
+        )
+        .groupBy(posts.threadId)
+        .toSQL().sql,
+    );
+
+    // Inner columns resolve against the subquery's own alias...
+    expect(generated).toContain(
+      "COALESCE( root.last_activity_at, root.published_at, root.updated_at )",
+    );
+    // ...and the correlation still points at the outer row, not at `root`.
+    expect(generated).toContain('root.id = "post"."thread_id"');
+  });
+
+  it("uses the root's own columns when rows are already roots", () => {
+    const { db } = createTestDatabase();
+    const generated = normalize(
+      (db as never as { select: (fields: unknown) => never })
+        .select({
+          id: posts.id,
+          activityAt: buildRootActivityExpr({
+            lastActivityAt: posts.lastActivityAt,
+            publishedAt: posts.publishedAt,
+            updatedAt: posts.updatedAt,
+          }),
+        })
+        .from(posts)
+        .innerJoin(threadCollections, eq(threadCollections.threadId, posts.id))
+        .toSQL().sql,
+    );
+
+    expect(generated).toContain(
+      'COALESCE( "post"."last_activity_at", "post"."published_at", "post"."updated_at" )',
+    );
+  });
+});

package/src/db/backfills/0005_split_thread_activity_from_quiet_replies.sql

@@ -0,0 +1,68 @@
+-- Split "last announced" from "last changed" for Threads.
+--
+-- Until now a quiet reply was implemented by *skipping* the recalculation of
+-- post.last_activity_at, and the quietness itself was never stored. That made
+-- the flag non-durable: the next recalculation (deleting any post in the
+-- Thread, changing a published_at, republishing) recomputed
+-- MAX(published_at) over the whole Thread, absorbed the quiet reply, and
+-- bumped the Thread on Latest anyway.
+--
+-- post.quiet_reply now persists the author's choice, so both timestamps are
+-- pure functions of the rows:
+--   last_activity_at  = MAX(published_at) excluding quiet replies  (Latest)
+--   thread_updated_at = MAX(published_at) including quiet replies  (archive)
+--
+-- Step 1 recovers the quiet decisions that are still visible in the data.
+-- A published reply can only sit later than its root's recorded
+-- last_activity_at if the recalculation was skipped for it — that is the
+-- signature of a quiet reply. Decisions that were already absorbed by a later
+-- recalculation are unrecoverable and stay false, which matches the ordering
+-- those sites are already seeing.
+--
+-- Steps 2 and 3 then recompute both timestamps from scratch.
+--
+-- Idempotent: after step 3 a quiet reply is still later than the recomputed
+-- last_activity_at (it is excluded from that MAX), so a rerun re-selects
+-- exactly the same rows, and every non-quiet published reply is covered by
+-- the MAX and can never be selected.
+
+-- Step 1: recover still-detectable quiet replies.
+UPDATE "post"
+SET "quiet_reply" = TRUE
+WHERE "post"."reply_to_id" IS NOT NULL
+  AND "post"."published_at" IS NOT NULL
+  AND EXISTS (
+    SELECT 1
+    FROM "post" AS root
+    WHERE root."site_id" = "post"."site_id"
+      AND root."id" = "post"."thread_id"
+      AND root."last_activity_at" IS NOT NULL
+      AND "post"."published_at" > root."last_activity_at"
+  );
+
+-- Step 2: thread_updated_at — newest published post in the Thread, quiet included.
+UPDATE "post"
+SET "thread_updated_at" = (
+  SELECT MAX(member."published_at")
+  FROM "post" AS member
+  WHERE member."site_id" = "post"."site_id"
+    AND member."thread_id" = "post"."id"
+    AND member."status" = 'published'
+)
+WHERE "post"."reply_to_id" IS NULL;
+
+-- Step 3: last_activity_at — newest announced post in the Thread.
+-- Threads with nothing published (drafts) keep whatever they had.
+UPDATE "post"
+SET "last_activity_at" = COALESCE(
+  (
+    SELECT MAX(member."published_at")
+    FROM "post" AS member
+    WHERE member."site_id" = "post"."site_id"
+      AND member."thread_id" = "post"."id"
+      AND member."status" = 'published'
+      AND member."quiet_reply" = FALSE
+  ),
+  "post"."last_activity_at"
+)
+WHERE "post"."reply_to_id" IS NULL;

package/src/db/migrations/0031_many_ego.sql

@@ -0,0 +1,3 @@
+ALTER TABLE `post` ADD `quiet_reply` integer DEFAULT false NOT NULL;--> statement-breakpoint
+ALTER TABLE `post` ADD `thread_updated_at` integer;--> statement-breakpoint
+CREATE INDEX `idx_post_site_root_thread_updated` ON `post` (`site_id`,`thread_updated_at`,`id`) WHERE "post"."reply_to_id" IS NULL AND "post"."status" = 'published';