@jant/core 0.6.15 → 0.7.0

package/src/client-site.ts

@@ -2,14 +2,21 @@
  * Static site client entry point (Hugo theme).
  *
  * Loaded on exported Hugo sites to enable reading-surface interactions —
- * media lightbox, feed video autoplay, audio waveform, and gallery scroll
- * hints. Does NOT include Datastar, auth, toast, or form plumbing; those
- * are runtime-only concerns for the authenticated app.
+ * media lightbox, feed video autoplay, audio waveform, gallery scroll hints,
+ * and the thread-context shell. Does NOT include Datastar, auth, toast, or
+ * form plumbing; those are runtime-only concerns for the authenticated app.
  */
 
 import "./client/audio-player.js";
 import "./client/feed-video-player.js";
 import "./client/media-scroll-hint.js";
 import "./client/site-header-nav.js";
+// A thread preview's ancestor context is server-rendered collapsed, and its
+// "Show more" is the only way back out of that. Off-site pages render the same
+// shell — the Hugo export's own thread-preview partial had to leave the shell
+// out entirely because this was missing — so the reading surface owes them the
+// script that makes it work. It binds on DOMContentLoaded to
+// `[data-thread-context-toggle]` and does nothing on a page carrying none.
+import "./client/thread-context.js";
 import "./client/components/jant-media-lightbox.js";
 import "./styles/site-media.css";

package/src/client.ts

@@ -11,8 +11,12 @@ import "./client/audio-player.js";
 import "./client/feed-video-player.js";
 import "./client/media-scroll-hint.js";
 import "./client/form-enter-submit.js";
+import "./client/copy-field.js";
 import "./client/components/jant-media-lightbox.js";
 import "./client/components/jant-text-preview.js";
+// First-run setup is a signed-out page, so the language picker it shares with
+// the settings page has to ship in the public bundle.
+import "./client/components/jant-locale-picker.js";
 import "./client/toast.js";
 import "./client/thread-context.js";
 import "./client/note-expand.js";

package/src/db/__tests__/backfill-nav-label-mirrors.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Executes the real 0006 backfill SQL against snapshot-shaped nav 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).
+ */
+
+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/0006_clear_mirrored_page_nav_labels.sql",
+  ),
+  "utf-8",
+);
+
+const POST_ID = "pst_backfill00000000000000001";
+const COLLECTION_ID = "col_backfill00000000000000001";
+
+describe("0006 backfill — clear nav labels that mirror their target", () => {
+  let sqlite: BetterSqlite3.Database;
+
+  function runBackfill() {
+    sqlite.exec(BACKFILL_SQL);
+  }
+
+  function labelOf(id: string): string {
+    const row = sqlite
+      .prepare(`SELECT label FROM nav_item WHERE id = ?`)
+      .get(id) as { label: string };
+    return row.label;
+  }
+
+  function insertNavItem(row: {
+    id: string;
+    type: "page" | "collection" | "link";
+    label: string;
+    position?: string;
+    postId?: string;
+    collectionId?: string;
+  }) {
+    sqlite
+      .prepare(
+        `INSERT INTO nav_item (
+           id, site_id, type, post_id, collection_id, label, url,
+           placement, position, created_at, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?, '/x', 'header', ?, 1, 1)`,
+      )
+      .run(
+        row.id,
+        DEFAULT_TEST_SITE_ID,
+        row.type,
+        row.postId ?? null,
+        row.collectionId ?? null,
+        row.label,
+        row.position ?? "a0",
+      );
+  }
+
+  beforeEach(() => {
+    sqlite = createTestDatabase().sqlite;
+    sqlite
+      .prepare(
+        `INSERT INTO post (
+           id, site_id, format, status, visibility, title, thread_id,
+           published_at, last_activity_at, created_at, updated_at
+         ) VALUES (?, ?, 'note', 'published', 'latest_hidden', 'About me', ?, 1, 1, 1, 1)`,
+      )
+      .run(POST_ID, DEFAULT_TEST_SITE_ID, POST_ID);
+    sqlite
+      .prepare(
+        `INSERT INTO collection (id, site_id, title, sort_order, created_at, updated_at)
+         VALUES (?, ?, 'Design Notes', 'newest', 1, 1)`,
+      )
+      .run(COLLECTION_ID, DEFAULT_TEST_SITE_ID);
+  });
+
+  it("clears a page label that only mirrors the post title", () => {
+    insertNavItem({
+      id: "nav_mirror0000000000000000001",
+      type: "page",
+      label: "About me",
+      postId: POST_ID,
+    });
+
+    runBackfill();
+
+    expect(labelOf("nav_mirror0000000000000000001")).toBe("");
+  });
+
+  it("clears a collection label that only mirrors the collection title", () => {
+    insertNavItem({
+      id: "nav_mirror0000000000000000002",
+      type: "collection",
+      label: "Design Notes",
+      collectionId: COLLECTION_ID,
+    });
+
+    runBackfill();
+
+    expect(labelOf("nav_mirror0000000000000000002")).toBe("");
+  });
+
+  it("keeps a label the author typed", () => {
+    insertNavItem({
+      id: "nav_custom0000000000000000001",
+      type: "page",
+      label: "Colophon",
+      postId: POST_ID,
+    });
+    insertNavItem({
+      id: "nav_custom0000000000000000002",
+      type: "link",
+      label: "About me",
+      position: "a1",
+    });
+
+    runBackfill();
+
+    expect(labelOf("nav_custom0000000000000000001")).toBe("Colophon");
+    // A free-form link has no target to follow, so its label is never cleared
+    // even when it happens to read like one.
+    expect(labelOf("nav_custom0000000000000000002")).toBe("About me");
+  });
+
+  it("is safe to rerun", () => {
+    insertNavItem({
+      id: "nav_mirror0000000000000000003",
+      type: "page",
+      label: "About me",
+      postId: POST_ID,
+    });
+
+    runBackfill();
+    runBackfill();
+
+    expect(labelOf("nav_mirror0000000000000000003")).toBe("");
+  });
+});

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__/schema-enum-sources.test.ts

@@ -0,0 +1,33 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+
+/**
+ * The schema files must not keep private copies of the value lists that
+ * `types/constants.ts` already owns.
+ *
+ * This is not a style rule. A CHECK constraint is generated from whatever list
+ * the schema file can see, so a private copy that stops matching the shared one
+ * produces a constraint that rejects rows the application considers valid — and
+ * the schema files are the one place where nothing else would catch it, because
+ * `drizzle-kit generate` happily emits the wrong constraint and the types still
+ * line up on both sides.
+ */
+const SCHEMA_FILES = ["../schema.ts", "../pg/schema.ts"];
+
+/** `const NAME = [...] as const`, the shape a value list is declared in. */
+const LOCAL_VALUE_LIST =
+  /const\s+([A-Z][A-Z0-9_]*)\s*=\s*\[[^\]]*\]\s*as const/g;
+
+describe("schema value lists", () => {
+  for (const file of SCHEMA_FILES) {
+    it(`${file} declares no value list of its own`, () => {
+      const source = readFileSync(resolve(__dirname, file), "utf8");
+      const declared = [...source.matchAll(LOCAL_VALUE_LIST)].map(
+        (match) => match[1],
+      );
+
+      expect(declared).toEqual([]);
+    });
+  }
+});