@jant/core 0.6.16 → 0.7.0

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

@@ -570,20 +570,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 +1603,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 +1618,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 () => {