@jant/core 0.6.16 → 0.7.1

package/src/services/__tests__/post-timeline.test.ts

@@ -486,6 +486,133 @@ describe("PostService - Timeline features", () => {
     });
   });
 
+  // A reply can be older than its root: a post moved into a Thread keeps its
+  // own creation time, and an export without `created` dates every post by
+  // publication. Thread order still opens on the root.
+  describe("a reply created before its root", () => {
+    async function createThreadWithOlderReplies() {
+      const root = await postService.create({
+        format: "note",
+        bodyMarkdown: "Root",
+        featured: true,
+        publishedAt: 3000,
+      });
+      const first = await postService.create({
+        format: "note",
+        bodyMarkdown: "First reply",
+        replyToId: root.id,
+        publishedAt: 1000,
+      });
+      const second = await postService.create({
+        format: "note",
+        bodyMarkdown: "Second reply",
+        replyToId: first.id,
+        publishedAt: 2000,
+      });
+      // Backdated after the fact, the way a restore lands them, so each test
+      // reads the shape without going through the reply guard.
+      for (const [id, createdAt] of [
+        [root.id, 3000],
+        [first.id, 1000],
+        [second.id, 2000],
+      ] as const) {
+        await db.update(posts).set({ createdAt }).where(eq(posts.id, id));
+      }
+      return { root, first, second };
+    }
+
+    it("opens getThread on the root", async () => {
+      const { root, first, second } = await createThreadWithOlderReplies();
+
+      const thread = await postService.getThread(root.id);
+
+      expect(thread.map((post) => post.id)).toEqual([
+        root.id,
+        first.id,
+        second.id,
+      ]);
+    });
+
+    it("opens getPublishedThreads on the root", async () => {
+      const { root, first, second } = await createThreadWithOlderReplies();
+
+      const threads = await postService.getPublishedThreads([root.id]);
+
+      expect(threads.get(root.id)?.map((post) => post.id)).toEqual([
+        root.id,
+        first.id,
+        second.id,
+      ]);
+    });
+
+    it("puts the root at position 0 of the Featured projection", async () => {
+      const { root, second } = await createThreadWithOlderReplies();
+
+      const result = await postService.getFeaturedThreadTimelineData([root.id]);
+
+      expect(
+        result
+          .get(root.id)
+          ?.posts.map(({ post, position }) => [post.id, position]),
+      ).toEqual([
+        [root.id, 0],
+        [second.id, 2],
+      ]);
+      expect(result.get(root.id)?.featuredPostIds).toEqual([root.id]);
+    });
+
+    it("ends the Thread on the newest reply, not the root", async () => {
+      const { root, second } = await createThreadWithOlderReplies();
+
+      const published = await postService.getThreadTailIds([root.id]);
+      const withDrafts = await postService.getThreadTailIds([root.id], {
+        includeDrafts: true,
+      });
+
+      expect(published.get(root.id)).toBe(second.id);
+      expect(withDrafts.get(root.id)).toBe(second.id);
+    });
+
+    it("refuses a reply to the root once a reply exists", async () => {
+      const { root, second } = await createThreadWithOlderReplies();
+
+      await expect(
+        postService.create({
+          format: "note",
+          bodyMarkdown: "Fork",
+          replyToId: root.id,
+        }),
+      ).rejects.toThrow("This post is no longer the end of the thread.");
+
+      const next = await postService.create({
+        format: "note",
+        bodyMarkdown: "Third reply",
+        replyToId: second.id,
+      });
+      expect(next.threadId).toBe(root.id);
+    });
+
+    it("folds the replies for the timeline in Thread order", async () => {
+      const { root, first, second } = await createThreadWithOlderReplies();
+
+      const context = (
+        await postService.getThreadTimelineContext([root.id])
+      ).get(root.id);
+      const previews = await postService.getThreadPreviews([root.id]);
+
+      expect(context?.leadingReplies.map((post) => post.id)).toEqual([
+        first.id,
+        second.id,
+      ]);
+      expect(context?.latestReply.id).toBe(second.id);
+      expect(context?.totalReplyCount).toBe(2);
+      expect(previews.get(root.id)?.map((post) => post.id)).toEqual([
+        first.id,
+        second.id,
+      ]);
+    });
+  });
+
   describe("timeline assembly", () => {
     it("fetches published non-reply posts for the timeline", async () => {
       const root = await postService.create({

package/src/services/__tests__/post.test.ts

@@ -13,6 +13,7 @@ import type { Database } from "../../db/index.js";
 import { createPathService } from "../path.js";
 import type { MediaService } from "../media.js";
 import { POST_BODY_HTML_VERSION } from "../../lib/post-body-html.js";
+import { ValidationError } from "../../lib/errors.js";
 import type BetterSqlite3 from "better-sqlite3";
 
 function createMockStorage() {
@@ -90,6 +91,79 @@ describe("PostService", () => {
       expect(post.threadId).toBe(post.id);
     });
 
+    it("stores an empty list item with the paragraph the schema requires", async () => {
+      const post = await postService.create({
+        format: "note",
+        body: JSON.stringify({
+          type: "doc",
+          content: [
+            {
+              type: "orderedList",
+              content: [
+                { type: "listItem", content: [] },
+                {
+                  type: "listItem",
+                  content: [
+                    {
+                      type: "paragraph",
+                      content: [{ type: "text", text: "Install" }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        }),
+      });
+
+      const stored = JSON.parse(post.body ?? "");
+      expect(stored.content[0].content[0]).toEqual({
+        type: "listItem",
+        content: [{ type: "paragraph" }],
+      });
+    });
+
+    it("restores the creation and edit times an import passes", async () => {
+      const published = await postService.create({
+        format: "note",
+        bodyMarkdown: "Moved from another site",
+        publishedAt: 1700000500,
+        createdAt: 1700000000,
+        updatedAt: 1700009000,
+      });
+      expect(published).toMatchObject({
+        createdAt: 1700000000,
+        updatedAt: 1700009000,
+        lastActivityAt: 1700000500,
+      });
+
+      const draft = await postService.create({
+        format: "note",
+        status: "draft",
+        bodyMarkdown: "Unfinished",
+        createdAt: 1700000000,
+        updatedAt: 1700004000,
+      });
+      expect(draft).toMatchObject({
+        createdAt: 1700000000,
+        updatedAt: 1700004000,
+        lastActivityAt: 1700004000,
+      });
+
+      const backdated = await postService.create({
+        format: "note",
+        bodyMarkdown: "Only a creation time",
+        createdAt: 1700000000,
+      });
+      expect(backdated.updatedAt).toBe(1700000000);
+    });
+
+    it("rejects a body that isn't TipTap JSON", async () => {
+      await expect(
+        postService.create({ format: "note", body: "not json" }),
+      ).rejects.toThrow(ValidationError);
+    });
+
     it("creates a link post with commentary", async () => {
       const body = JSON.stringify({
         type: "doc",
@@ -570,20 +644,53 @@ describe("PostService", () => {
       const descending = await postService.list({
         sortOrder: "rating_desc",
       });
-      const ascending = await postService.list({
-        sortOrder: "rating_asc",
-      });
 
       expect(descending.map((post) => post.bodyText)).toEqual([
         "five stars",
         "three stars",
         "unrated newest",
       ]);
-      expect(ascending.map((post) => post.bodyText)).toEqual([
-        "three stars",
-        "five stars",
-        "unrated newest",
+    });
+
+    it("orders by time for an explicit newest, ratings and all", async () => {
+      // `newest` used to have no branch of its own in the ORDER BY and fell
+      // into the one written for the ascending rating order, so anything that
+      // named it — a smart collection page, most visibly — got its posts
+      // grouped by rating instead of dated. Rated rows here on purpose.
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "oldest, best",
+        publishedAt: 1000,
+        rating: 5,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "middle, worst",
+        publishedAt: 2000,
+        rating: 1,
+      });
+      await postService.create({
+        format: "note",
+        bodyMarkdown: "newest, unrated",
+        publishedAt: 3000,
+      });
+
+      const ordered = await postService.list({ sortOrder: "newest" });
+      expect(ordered.map((post) => post.bodyText)).toEqual([
+        "newest, unrated",
+        "middle, worst",
+        "oldest, best",
       ]);
+
+      // The keyset cursor reads the same keys or pagination skips rows.
+      expect(
+        (
+          await postService.list({
+            sortOrder: "newest",
+            cursor: ordered[0]?.id,
+          })
+        ).map((post) => post.bodyText),
+      ).toEqual(["middle, worst", "oldest, best"]);
     });
 
     it("orders drafts by updatedAt descending", async () => {
@@ -1570,7 +1677,7 @@ describe("PostService", () => {
       expect(updated?.pinnedAt).toBeTypeOf("number");
     });
 
-    it("updates slug and its page navigation URL", async () => {
+    it("updates slug and title on its page navigation entry", async () => {
       const post = await postService.create({
         format: "note",
         title: "Test page",
@@ -1585,11 +1692,15 @@ describe("PostService", () => {
 
       const updated = await postService.update(post.id, {
         slug: "new-slug",
+        title: "Renamed page",
       });
 
       expect(updated?.slug).toBe("new-slug");
+      // The URL is synced on write; the title is read through, so renaming the
+      // page carries its navigation entry along with no sync step at all.
       expect(await navItemService.getById(navItem.id)).toMatchObject({
-        label: "Test page",
+        label: "",
+        targetTitle: "Renamed page",
         url: "/new-slug",
       });
     });

package/src/services/__tests__/settings.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import {
   createTestDatabase,
   DEFAULT_TEST_SITE_ID,
@@ -170,7 +170,6 @@ describe("SettingsService", () => {
       siteDescription: "",
       siteFooter: "",
       siteLanguage: "en",
-      cjkSerifFont: "off",
       showJantBrandingOnHome: false,
       mainRssFeed: "featured",
       timeZone: "UTC",
@@ -361,6 +360,57 @@ describe("SettingsService", () => {
       const result = await settingsService.isOnboardingComplete();
       expect(result).toBe(true);
     });
+
+    it("reports the three first-run states", async () => {
+      expect(await settingsService.getOnboardingStatus()).toBe("pending");
+
+      await settingsService.markSiteProvisioned();
+      expect(await settingsService.getOnboardingStatus()).toBe("provisioned");
+      // A provisioned site is real, but setup is not finished with it.
+      expect(await settingsService.isOnboardingComplete()).toBe(false);
+
+      await settingsService.completeOnboarding();
+      expect(await settingsService.getOnboardingStatus()).toBe("completed");
+    });
+
+    it("finishes setup when the author confirms the language they write in", async () => {
+      await settingsService.markSiteProvisioned();
+      // The control plane's guess, taken from the locale the owner browsed it
+      // in, is what the site starts with.
+      await settingsService.set("SITE_LANGUAGE", "zh-Hans");
+
+      await settingsService.confirmFirstRunLanguage(
+        { siteLanguage: "en", browserLanguage: "zh-Hans" },
+        { oldLanguage: "zh-Hans" },
+      );
+
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("en");
+      // English site, Chinese dashboard — the split the question exists for.
+      expect(await settingsService.get("DASHBOARD_LANGUAGE")).toBe("zh-Hans");
+      expect(await settingsService.isOnboardingComplete()).toBe(true);
+    });
+
+    it("leaves the dashboard following when the browser sent none", async () => {
+      await settingsService.confirmFirstRunLanguage(
+        { siteLanguage: "zh-TW", browserLanguage: "" },
+        { oldLanguage: "en" },
+      );
+
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("zh-TW");
+      expect(await settingsService.get("DASHBOARD_LANGUAGE")).toBeNull();
+    });
+
+    it("leaves the dashboard following the language the author confirmed", async () => {
+      // An English browser says nothing about someone who just answered
+      // "Simplified Chinese" — the dashboard follows that answer.
+      await settingsService.confirmFirstRunLanguage(
+        { siteLanguage: "zh-Hans", browserLanguage: "en-US" },
+        { oldLanguage: "en" },
+      );
+
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("zh-Hans");
+      expect(await settingsService.get("DASHBOARD_LANGUAGE")).toBeNull();
+    });
   });
 
   describe("grouped settings updates", () => {
@@ -390,7 +440,6 @@ describe("SettingsService", () => {
       const result = await settingsService.updateLocaleSettings(
         {
           siteLanguage: "zh-Hans",
-          cjkSerifFont: "zh-Hans",
           timeZone: "America/New_York",
         },
         {
@@ -400,29 +449,32 @@ describe("SettingsService", () => {
 
       expect(result.languageChanged).toBe(true);
       expect(await settingsService.get("SITE_LANGUAGE")).toBe("zh-Hans");
-      expect(await settingsService.get("CJK_SERIF_FONT")).toBe("zh-Hans");
       expect(await settingsService.get("TIME_ZONE")).toBe("America/New_York");
     });
 
-    it("removes CJK_SERIF_FONT when set to off", async () => {
-      await settingsService.set("CJK_SERIF_FONT", "zh-Hans");
+    // The Language and General pages each own part of this group, so an absent
+    // field has to mean "leave it alone" rather than "clear it".
+    it("leaves out-of-scope fields untouched", async () => {
+      await settingsService.set("SITE_LANGUAGE", "ja");
+      await settingsService.set("TIME_ZONE", "Asia/Tokyo");
+
       await settingsService.updateLocaleSettings(
-        {
-          siteLanguage: "en",
-          cjkSerifFont: "off",
-          timeZone: "UTC",
-        },
-        { oldLanguage: "en" },
+        { timeZone: "America/New_York" },
+        { oldLanguage: "ja" },
       );
+      expect(await settingsService.get("SITE_LANGUAGE")).toBe("ja");
 
-      expect(await settingsService.get("CJK_SERIF_FONT")).toBeNull();
+      await settingsService.updateLocaleSettings(
+        { siteLanguage: "en" },
+        { oldLanguage: "ja" },
+      );
+      expect(await settingsService.get("TIME_ZONE")).toBe("America/New_York");
     });
 
     it("stores the base locale when language input is blank", async () => {
       const result = await settingsService.updateLocaleSettings(
         {
           siteLanguage: "",
-          cjkSerifFont: "off",
           timeZone: "UTC",
         },
         {
@@ -439,7 +491,6 @@ describe("SettingsService", () => {
         {
           siteLanguage: "fr",
           dashboardLanguage: "zh-Hant",
-          cjkSerifFont: "off",
           timeZone: "UTC",
         },
         { oldLanguage: "fr", oldDashboardLanguage: "" },
@@ -456,7 +507,6 @@ describe("SettingsService", () => {
         {
           siteLanguage: "en",
           dashboardLanguage: "",
-          cjkSerifFont: "off",
           timeZone: "UTC",
         },
         { oldLanguage: "en", oldDashboardLanguage: "zh-Hans" },
@@ -481,7 +531,6 @@ describe("SettingsService", () => {
           {
             siteLanguage: "en",
             dashboardLanguage: "fr",
-            cjkSerifFont: "off",
             timeZone: "UTC",
           },
           { oldLanguage: "en" },
@@ -509,4 +558,166 @@ describe("SettingsService", () => {
       ).toBeNull();
     });
   });
+
+  /**
+   * The ping exists so a self-hosted site can be found at all, and it says
+   * "read me now" rather than "list me". What it fires on is therefore the
+   * interesting part: the two moments the answer changes, and neither of the
+   * moments it does not.
+   */
+  describe("updateDiscoverSetting", () => {
+    it("stores the choice explicitly, including off", async () => {
+      await settingsService.updateDiscoverSetting("off", { demoMode: false });
+      expect(await settingsService.get("DISCOVER")).toBe("off");
+
+      await settingsService.updateDiscoverSetting("featured", {
+        demoMode: false,
+      });
+      expect(await settingsService.get("DISCOVER")).toBe("featured");
+    });
+
+    // A site that has never used the control has never told anyone it exists,
+    // so confirming the default is exactly as much of an opt-in as ticking a
+    // box that was off.
+    it("announces when an untouched site opts in", async () => {
+      const result = await settingsService.updateDiscoverSetting("latest", {
+        demoMode: false,
+      });
+      expect(result.shouldAnnounce).toBe(true);
+    });
+
+    it("announces when a site that had opted out comes back", async () => {
+      await settingsService.updateDiscoverSetting("off", { demoMode: false });
+      const result = await settingsService.updateDiscoverSetting("latest", {
+        demoMode: false,
+      });
+      expect(result.shouldAnnounce).toBe(true);
+    });
+
+    // The directory already knows about a listed site; which of its posts it
+    // draws from is not news.
+    it("says nothing when an enrolled site changes which posts it offers", async () => {
+      await settingsService.updateDiscoverSetting("latest", {
+        demoMode: false,
+      });
+      const result = await settingsService.updateDiscoverSetting("featured", {
+        demoMode: false,
+      });
+      expect(result.shouldAnnounce).toBe(false);
+    });
+
+    // The half that used to be missing. A directory that is not told keeps the
+    // blog until its next scheduled read of the feed, and the owner watches
+    // something they just removed sit there for another hour.
+    it("announces when a listed site opts out", async () => {
+      await settingsService.updateDiscoverSetting("latest", {
+        demoMode: false,
+      });
+      const result = await settingsService.updateDiscoverSetting("off", {
+        demoMode: false,
+      });
+      expect(result.shouldAnnounce).toBe(true);
+    });
+
+    // Nothing changed, so there is nothing to say: this site was not in any
+    // directory a moment ago either.
+    it("says nothing when a site that was never listed sets off", async () => {
+      const result = await settingsService.updateDiscoverSetting("off", {
+        demoMode: false,
+      });
+      expect(result.shouldAnnounce).toBe(false);
+    });
+
+    it("never announces a demo site", async () => {
+      const result = await settingsService.updateDiscoverSetting("latest", {
+        demoMode: true,
+      });
+      expect(result.shouldAnnounce).toBe(false);
+    });
+  });
+
+  /**
+   * The stored outcome is the owner's record of the announcement, and it does
+   * not always reach them — a hosted site's settings page hides the status
+   * block entirely. The log is how a deployment answers "did that get through"
+   * when the dashboard cannot.
+   */
+  describe("announceToDiscover", () => {
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    function stubDirectory(response: Response | Error) {
+      return vi
+        .spyOn(globalThis, "fetch")
+        .mockImplementation(() =>
+          response instanceof Error
+            ? Promise.reject(response)
+            : Promise.resolve(response.clone()),
+        );
+    }
+
+    it("records and logs an announcement that got through", async () => {
+      stubDirectory(new Response(null, { status: 202 }));
+      const log = vi.spyOn(console, "log").mockImplementation(() => {});
+
+      const outcome = await settingsService.announceToDiscover({
+        endpoint: "https://cloud.example/api/discover/ping",
+        feedUrl: "https://blog.example/latest/feed",
+      });
+
+      expect(outcome.ok).toBe(true);
+      expect(
+        JSON.parse(
+          (await settingsService.get("DISCOVER_ANNOUNCE_STATE")) ?? "",
+        ),
+      ).toMatchObject({
+        ok: true,
+        feedUrl: "https://blog.example/latest/feed",
+      });
+      expect(log).toHaveBeenCalledWith(
+        expect.stringContaining("https://cloud.example/api/discover/ping"),
+      );
+    });
+
+    // The failure this exists for: a directory that answers, but not about
+    // this site. Silently stored, it reads from the dashboard like a success.
+    it("logs the reason an announcement failed", async () => {
+      stubDirectory(new Response(null, { status: 404 }));
+      const error = vi.spyOn(console, "error").mockImplementation(() => {});
+
+      const outcome = await settingsService.announceToDiscover({
+        endpoint: "https://jant.me/api/discover/ping",
+        feedUrl: "https://blog.example/latest/feed",
+      });
+
+      expect(outcome).toMatchObject({ ok: false, status: 404 });
+      expect(error).toHaveBeenCalledWith(
+        expect.stringContaining("The directory answered 404."),
+      );
+    });
+
+    // The caller orphans this promise behind `waitUntil`, so a rejection has
+    // nobody to reject to — on a Node runtime an unhandled one ends the
+    // process. A settings row that could not be written is worth a log, not
+    // the site.
+    it("resolves even when the outcome cannot be recorded", async () => {
+      stubDirectory(new Response(null, { status: 202 }));
+      vi.spyOn(console, "log").mockImplementation(() => {});
+      const error = vi.spyOn(console, "error").mockImplementation(() => {});
+      vi.spyOn(settingsService, "set").mockRejectedValue(
+        new Error("D1_ERROR: database is locked"),
+      );
+
+      const outcome = await settingsService.announceToDiscover({
+        endpoint: "https://jant.me/api/discover/ping",
+        feedUrl: "https://blog.example/latest/feed",
+      });
+
+      expect(outcome.ok).toBe(true);
+      expect(error).toHaveBeenCalledWith(
+        expect.stringContaining("database is locked"),
+      );
+    });
+  });
 });

package/src/services/__tests__/site-admin.test.ts

@@ -53,9 +53,9 @@ describe("SiteAdminService", () => {
 
     expect(navigationRows).toEqual([
       { systemKey: "featured", placement: "header" },
-      { systemKey: "collections", placement: "header" },
       { systemKey: "archive", placement: "header" },
-      { systemKey: "rss", placement: "more" },
+      { systemKey: "collections", placement: "more" },
+      { systemKey: "subscribe", placement: "more" },
       { systemKey: "settings", placement: "more" },
     ]);
   });
@@ -182,12 +182,12 @@ describe("SiteAdminService", () => {
     expect(recovered.site.id).toBe(first.site.id);
     expect(navigationRows.map((row) => row.systemKey)).toEqual([
       "featured",
-      "collections",
       "archive",
-      "rss",
+      "collections",
+      "subscribe",
       "settings",
     ]);
-    expect(onboarding.value).toBe("completed");
+    expect(onboarding.value).toBe("provisioned");
   });
 
   it("rejects reuse of an idempotency key with different key or primary host", async () => {