@jant/core 0.6.16 → 0.7.1

package/src/lib/__tests__/resolve-config.test.ts

@@ -31,9 +31,9 @@ describe("resolveConfig", () => {
     expect(config.publicApiEnabled).toBe(true);
     expect(config.rssFeedsEnabled).toBe(true);
     expect(config.demoMode).toBe(false);
-    expect(config.pageSize).toBe(50);
-    expect(config.searchPageSize).toBe(50);
-    expect(config.archivePageSize).toBe(50);
+    expect(config.pageSize).toBe(25);
+    expect(config.searchPageSize).toBe(25);
+    expect(config.archivePageSize).toBe(25);
     expect(config.rssFeedLimit).toBe(50);
     expect(config.rssPublishDelaySeconds).toBe(300);
   });
@@ -52,6 +52,73 @@ describe("resolveConfig", () => {
     expect(config.siteName).toBe("FromEnv");
   });
 
+  // A settings row holding an empty string is not always the same thing. The
+  // editor decides: a boolean, a number, and an enum with fixed options cannot
+  // be saved empty, so an empty one of those came from a path that skipped
+  // validation — a snapshot import replaying raw SQL — and the environment
+  // variable should still be heard.
+  // Text can legitimately be empty, and then the row wins.
+  describe("empty settings rows", () => {
+    it("lets an environment value through an empty boolean row", () => {
+      const config = resolveConfig(makeEnv({ NOINDEX: "true" }), {
+        NOINDEX: "",
+      });
+
+      expect(config.noindex).toBe(true);
+    });
+
+    it("falls back to the default for an empty boolean row with no env value", () => {
+      const config = resolveConfig(makeEnv(), { NOINDEX: "" });
+
+      expect(config.noindex).toBe(false);
+    });
+
+    it("still lets a saved boolean row override the environment", () => {
+      const config = resolveConfig(makeEnv({ NOINDEX: "true" }), {
+        NOINDEX: "false",
+      });
+
+      expect(config.noindex).toBe(false);
+    });
+
+    it("lets an environment value through an empty numeric row", () => {
+      const config = resolveConfig(makeEnv({ PAGE_SIZE: "20" }), {
+        PAGE_SIZE: "",
+      });
+
+      expect(config.pageSize).toBe(20);
+    });
+
+    it("keeps an empty enum row ahead of the environment when empty is an option", () => {
+      // `DASHBOARD_LANGUAGE` lists "" among its options — it is how the
+      // dashboard is told to follow the site language.
+      const config = resolveConfig(makeEnv({ DASHBOARD_LANGUAGE: "zh-Hans" }), {
+        DASHBOARD_LANGUAGE: "",
+      });
+
+      expect(config.dashboardLanguage).toBe("");
+    });
+
+    it("keeps an empty text row ahead of the environment", () => {
+      const config = resolveConfig(
+        makeEnv({ SITE_FOOTER: "From environment" }),
+        { SITE_FOOTER: "" },
+      );
+
+      expect(config.siteFooter).toBe("");
+    });
+
+    it("lets an environment value through an empty enum row", () => {
+      // `MAIN_RSS_FEED` offers "featured" and "latest" and nothing else, so an
+      // empty row is as impossible to save as an empty boolean.
+      const config = resolveConfig(makeEnv({ MAIN_RSS_FEED: "latest" }), {
+        MAIN_RSS_FEED: "",
+      });
+
+      expect(config.mainRssFeed).toBe("latest");
+    });
+  });
+
   it("lets an explicit empty DB value override an environment fallback", () => {
     const config = resolveConfig(
       makeEnv({ SITE_DESCRIPTION: "From environment" }),
@@ -81,6 +148,34 @@ describe("resolveConfig", () => {
     expect(config.mainRssFeed).toBe("featured");
   });
 
+  it("resolves archiveDefaultLayout from DB, env, and defaults", () => {
+    const defaultConfig = resolveConfig(makeEnv(), {});
+    expect(defaultConfig.archiveDefaultLayout).toBe("list");
+
+    const envConfig = resolveConfig(
+      makeEnv({ ARCHIVE_DEFAULT_LAYOUT: "grid" }),
+      {},
+    );
+    expect(envConfig.archiveDefaultLayout).toBe("grid");
+
+    const dbConfig = resolveConfig(
+      makeEnv({ ARCHIVE_DEFAULT_LAYOUT: "list" }),
+      {
+        ARCHIVE_DEFAULT_LAYOUT: "grid",
+      },
+    );
+    expect(dbConfig.archiveDefaultLayout).toBe("grid");
+  });
+
+  it("falls back when the archive layout setting is invalid", () => {
+    const config = resolveConfig(
+      makeEnv({ ARCHIVE_DEFAULT_LAYOUT: "carousel" }),
+      {},
+    );
+
+    expect(config.archiveDefaultLayout).toBe("list");
+  });
+
   it("normalizes legacy time zone values from the database", () => {
     const config = resolveConfig(makeEnv(), { TIME_ZONE: "Beijing" });
 
@@ -172,6 +267,39 @@ describe("resolveConfig", () => {
     expect(config.siteAvatarUrl).toBe(
       "https://r2.example.com/media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
     );
+    // Without a transform there is nothing to size it down with, so the
+    // header falls back to the canonical asset.
+    expect(config.siteAvatarThumbUrl).toBe(config.siteAvatarUrl);
+  });
+
+  it("sizes the header avatar down when an image transform is configured", () => {
+    const config = resolveConfig(
+      makeEnv({
+        R2_PUBLIC_URL: "https://r2.example.com",
+        IMAGE_TRANSFORM_URL: "https://r2.example.com/cdn-cgi/image",
+        STORAGE_DRIVER: "r2",
+      }),
+      {
+        SITE_AVATAR:
+          "media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
+      },
+    );
+
+    // The canonical URL stays full-resolution: it is what the social card and
+    // the settings editor need.
+    expect(config.siteAvatarUrl).toBe(
+      "https://r2.example.com/media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
+    );
+    expect(config.siteAvatarThumbUrl).toBe(
+      "https://r2.example.com/cdn-cgi/image/width=128,quality=80,format=auto,fit=scale-down/https://r2.example.com/media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
+    );
+  });
+
+  it("leaves both avatar URLs empty without a stored avatar", () => {
+    const config = resolveConfig(makeEnv({}), {});
+
+    expect(config.siteAvatarUrl).toBe("");
+    expect(config.siteAvatarThumbUrl).toBe("");
   });
 
   it("returns empty siteAvatarUrl when no avatar set", () => {

package/src/lib/__tests__/schemas.test.ts

@@ -9,11 +9,12 @@ import {
   CreatePostApiSchema,
   UpdatePostSchema,
   UpdatePostApiSchema,
-  SetupSchema,
+  SetupAccountSchema,
   SigninSchema,
   UpdateSiteSettingsSchema,
   normalizeEmail,
   parseFormData,
+  PostFilterSelectionSchema,
   parseFormDataOptional,
   validateAttachmentCount,
 } from "../schemas.js";
@@ -60,10 +61,17 @@ describe("RedirectTypeSchema", () => {
     expect(RedirectTypeSchema.parse("302")).toBe("302");
   });
 
+  // The custom URL list answers `redirectType: 301`; sending that back to
+  // create one has to work.
+  it("accepts 301 and 302 as numbers, as the API answers them", () => {
+    expect(RedirectTypeSchema.parse(301)).toBe("301");
+    expect(RedirectTypeSchema.parse(302)).toBe("302");
+  });
+
   it("rejects other values", () => {
     expect(() => RedirectTypeSchema.parse("200")).toThrow();
     expect(() => RedirectTypeSchema.parse("404")).toThrow();
-    expect(() => RedirectTypeSchema.parse(301)).toThrow();
+    expect(() => RedirectTypeSchema.parse(308)).toThrow();
   });
 });
 
@@ -75,10 +83,9 @@ describe("normalizeEmail", () => {
   });
 });
 
-describe("SetupSchema", () => {
+describe("SetupAccountSchema", () => {
   it("normalizes email before returning parsed data", () => {
-    const result = SetupSchema.parse({
-      siteName: "Jant",
+    const result = SetupAccountSchema.parse({
       email: "  Admin@Example.COM ",
       password: "password123",
     });
@@ -617,6 +624,25 @@ describe("CreatePostApiSchema", () => {
     status: "published",
   };
 
+  it("accepts the creation and edit times a restore passes", () => {
+    expect(
+      CreatePostApiSchema.parse({
+        ...validPost,
+        createdAt: 1700000000,
+        updatedAt: 1700009000,
+      }),
+    ).toMatchObject({ createdAt: 1700000000, updatedAt: 1700009000 });
+  });
+
+  it("leaves record timestamps out of updates", () => {
+    expect(
+      UpdatePostApiSchema.safeParse({ createdAt: 1700000000 }).success,
+    ).toBe(false);
+    expect(
+      UpdatePostApiSchema.safeParse({ updatedAt: 1700000000 }).success,
+    ).toBe(false);
+  });
+
   it("accepts ordered attachment inputs", () => {
     const mediaId = createEntityId("media");
     const result = CreatePostApiSchema.parse({
@@ -816,3 +842,41 @@ describe("validateAttachmentCount", () => {
     );
   });
 });
+
+describe("PostFilterSelectionSchema", () => {
+  it("accepts a selection a smart collection may store", () => {
+    const result = PostFilterSelectionSchema.safeParse({
+      format: "note",
+      media: "any",
+      visibility: "featured",
+      collection: ["col_01m0f291t3fzvte3vj2g8d611z"],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts the empty selection, which means every post", () => {
+    expect(PostFilterSelectionSchema.safeParse({}).success).toBe(true);
+  });
+
+  it("refuses the private visibility a smart collection can never name", () => {
+    expect(
+      PostFilterSelectionSchema.safeParse({ visibility: "private" }).success,
+    ).toBe(false);
+  });
+
+  it("refuses a key that is not a dimension", () => {
+    expect(
+      PostFilterSelectionSchema.safeParse({ language: "en" }).success,
+    ).toBe(false);
+  });
+
+  it("names the condition it rejected", () => {
+    const result = PostFilterSelectionSchema.safeParse({ year: 1970 });
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error.issues[0]?.path).toEqual(["year"]);
+    expect(result.error.issues[0]?.message).toBe(
+      "Invalid value for the year condition",
+    );
+  });
+});

package/src/lib/__tests__/site-unavailable-page.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { renderSiteUnavailablePage } from "../site-unavailable-page.js";
+
+describe("renderSiteUnavailablePage", () => {
+  it("links back to the configured hosting provider", () => {
+    const html = renderSiteUnavailablePage({
+      HOSTED_CONTROL_PLANE_BASE_URL: "https://cloud-jant.localtest.me",
+      HOSTED_CONTROL_PLANE_PROVIDER_NAME: "Jant Cloud",
+      SITE_RESOLUTION_MODE: "host-based",
+    });
+
+    expect(html).toContain("This site is offline");
+    expect(html).toContain(
+      '<a href="https://cloud-jant.localtest.me/app">Jant Cloud</a>',
+    );
+  });
+
+  it("stays provider-neutral when no control plane is configured", () => {
+    const html = renderSiteUnavailablePage({});
+
+    expect(html).toContain("There's nothing to read here right now");
+    expect(html).toContain("sign in to your hosting provider");
+    expect(html).not.toContain("<a ");
+  });
+});

package/src/lib/__tests__/slug.test.ts

@@ -141,4 +141,74 @@ describe("generatePostSlug", () => {
       ).rejects.toThrow("Could not generate a unique slug");
     });
   });
+
+  describe("language suffix", () => {
+    /** Every slug is taken except the ones listed. */
+    const onlyAvailable = (...free: string[]) => {
+      const allowed = new Set(free);
+      return async (slug: string) => allowed.has(slug);
+    };
+
+    it("is not used when the base slug is free", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toBe("book-review");
+    });
+
+    it("is tried before a random suffix when the base collides", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: onlyAvailable("book-review-en"),
+      });
+      expect(slug).toBe("book-review-en");
+    });
+
+    it("keeps the multi-part tag intact", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "zh-hant",
+        isAvailable: onlyAvailable("book-review-zh-hant"),
+      });
+      expect(slug).toBe("book-review-zh-hant");
+    });
+
+    it("falls back to a random suffix when the language slug is taken too", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: async (candidate: string) =>
+          candidate !== "book-review" && candidate !== "book-review-en",
+      });
+      expect(slug).toMatch(/^book-review-[a-z0-9]{5}$/);
+    });
+
+    it("goes straight to a random suffix without one", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        isAvailable: async (candidate: string) => candidate !== "book-review",
+      });
+      expect(slug).toMatch(/^book-review-[a-z0-9]{5}$/);
+    });
+
+    it("skips a language candidate that lands on a reserved path", async () => {
+      const slug = await generatePostSlug({
+        title: "feed",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: alwaysAvailable,
+      });
+      // "feed" is reserved, so the base is never offered and the language
+      // candidate is never reached — the random fallback owns this case.
+      expect(slug).toMatch(/^feed-[a-z0-9]{5}$/);
+    });
+  });
 });

package/src/lib/__tests__/slugify.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+import { slugify } from "../slugify.js";
+
+describe("slugify", () => {
+  it("converts text to lowercase hyphenated slug", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("removes special characters", () => {
+    expect(slugify("Hello World! This is a Test.")).toBe(
+      "hello-world-this-is-a-test",
+    );
+  });
+
+  it("collapses multiple spaces", () => {
+    expect(slugify("Multiple   Spaces")).toBe("multiple-spaces");
+  });
+
+  it("trims leading/trailing whitespace and hyphens", () => {
+    expect(slugify("  Multiple   Spaces  ")).toBe("multiple-spaces");
+  });
+
+  it("replaces underscores with hyphens", () => {
+    expect(slugify("hello_world")).toBe("hello-world");
+  });
+
+  it("handles already-slugified text", () => {
+    expect(slugify("already-a-slug")).toBe("already-a-slug");
+  });
+
+  it("handles empty string", () => {
+    expect(slugify("")).toBe("");
+  });
+
+  it("transliterates accented characters", () => {
+    expect(slugify("café & résumé")).toBe("cafe-and-resume");
+  });
+
+  it("converts Chinese characters to pinyin", () => {
+    expect(slugify("书评")).toBe("shu-ping");
+  });
+
+  it("handles mixed Chinese and English text", () => {
+    expect(slugify("我的 Blog")).toBe("wo-de-blog");
+  });
+
+  it("handles CJK characters with spaces", () => {
+    expect(slugify("电影 评论")).toBe("dian-ying-ping-lun");
+  });
+
+  it("romanizes Korean titles", () => {
+    expect(slugify("안녕하세요 세계")).toBe("annyeonghaseyo-segye");
+    expect(slugify("개발 일지 3일차")).toBe("gaebal-ilji-3ilcha");
+  });
+
+  it("romanizes kana-only Japanese titles", () => {
+    expect(slugify("カタカナタイトル")).toBe("katakanataitoru");
+    expect(slugify("ハンバーガー")).toBe("hanbaga");
+  });
+
+  it("keeps Latin words in mostly-kana Japanese titles", () => {
+    expect(slugify("React入門ガイド")).toBe("react-gaido");
+  });
+
+  it("returns empty for kanji-heavy Japanese titles instead of garbling them", () => {
+    // Kanji carries the meaning; without a reading dictionary any output
+    // would be gibberish, so callers should fall back to a random ID.
+    expect(slugify("日本語のタイトルです")).toBe("");
+    expect(slugify("東京タワーに行った")).toBe("");
+    expect(slugify("こんにちは世界")).toBe("");
+  });
+
+  it("returns empty for scripts with no usable transliteration", () => {
+    expect(slugify("שלום עולם")).toBe("");
+    expect(slugify("สวัสดีชาวโลก")).toBe("");
+  });
+
+  it("returns empty when most of the title is untransliterable", () => {
+    expect(slugify("שלום world")).toBe("");
+  });
+
+  it("returns empty for emoji-only titles", () => {
+    expect(slugify("🎉🎉")).toBe("");
+  });
+});

package/src/lib/__tests__/storage.test.ts

@@ -210,6 +210,38 @@ describe("createS3Driver", () => {
       "x-amz-checksum-sha256": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
     });
   });
+
+  it("omits a request checksum when the caller did not supply one", async () => {
+    const driver = createS3Driver({
+      endpoint: "https://s3.example.com",
+      bucket: "jant-media",
+      accessKeyId: "access-key",
+      secretAccessKey: "secret-key",
+      region: "auto",
+    });
+
+    const presigned = await driver.presignPut?.("media/test.webp", {
+      contentType: "image/webp",
+      contentDisposition: "inline",
+      cacheControl: "public, max-age=31536000, immutable",
+      expiresInSeconds: 900,
+    });
+
+    if (!presigned) {
+      throw new Error("Expected presigned PUT target");
+    }
+
+    // Presigning runs with an empty body, so a default request checksum would
+    // pin CRC32-of-nothing to the URL and every real upload would 400.
+    const params = new URL(presigned.url).searchParams;
+    expect(params.has("x-amz-checksum-crc32")).toBe(false);
+    expect(params.has("x-amz-sdk-checksum-algorithm")).toBe(false);
+    expect(presigned.headers).toEqual({
+      "Content-Type": "image/webp",
+      "Content-Disposition": "inline",
+      "Cache-Control": "public, max-age=31536000, immutable",
+    });
+  });
 });
 
 describe("createR2Driver", () => {

package/src/lib/__tests__/thread-fold.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import {
+  foldThreadReplies,
+  getThreadHiddenCount,
+  THREAD_LEADING_REPLIES,
+  THREAD_TRAILING_REPLIES,
+} from "../thread-fold.js";
+
+const reply = (n: number) => ({ id: `reply-${n}` });
+const replies = (count: number) =>
+  Array.from({ length: count }, (_unused, index) => reply(index + 1));
+
+const ids = (list: { id: string }[]) => list.map((item) => item.id);
+
+describe("foldThreadReplies", () => {
+  it("has no fold for a thread with no replies", () => {
+    expect(foldThreadReplies([])).toBeNull();
+  });
+
+  // The window is the first two plus the last three, so anything up to six
+  // posts arrives whole and there is nothing for a gap link to stand for.
+  it.each([1, 2, 3, 4, 5])("hides nothing with %i replies", (count) => {
+    const fold = foldThreadReplies(replies(count));
+
+    expect(fold?.hiddenCount).toBe(0);
+    expect(fold?.firstHiddenReply).toBeNull();
+    // Every reply is shown exactly once, the hero included.
+    const shown = [
+      ...ids(fold?.leadingReplies ?? []),
+      ...ids(fold?.trailingReplies ?? []),
+      fold?.latestReply.id,
+    ];
+    expect(new Set(shown).size).toBe(shown.length);
+    expect(shown.length).toBe(count);
+  });
+
+  // The shortest thread puts one reply in every role at once. It must still
+  // be rendered once, not three times.
+  it("shows a lone reply once, as the hero", () => {
+    const fold = foldThreadReplies(replies(1));
+
+    expect(fold?.latestReply.id).toBe("reply-1");
+    expect(fold?.leadingReplies).toEqual([]);
+    expect(fold?.trailingReplies).toEqual([]);
+  });
+
+  it("folds the middle out of a long thread", () => {
+    const fold = foldThreadReplies(replies(7));
+
+    expect(ids(fold?.leadingReplies ?? [])).toEqual(["reply-1", "reply-2"]);
+    expect(ids(fold?.trailingReplies ?? [])).toEqual(["reply-5", "reply-6"]);
+    expect(fold?.latestReply.id).toBe("reply-7");
+    expect(fold?.hiddenCount).toBe(2);
+  });
+
+  // The gap stands for a run of posts and opens the first of them, so a reader
+  // following it lands where the missing stretch starts.
+  it("points the gap at the earliest post it hides", () => {
+    expect(foldThreadReplies(replies(20))?.firstHiddenReply?.id).toBe(
+      "reply-3",
+    );
+  });
+
+  it("keeps the window fixed however long the thread runs", () => {
+    const fold = foldThreadReplies(replies(50));
+    const shown =
+      (fold?.leadingReplies.length ?? 0) +
+      (fold?.trailingReplies.length ?? 0) +
+      1;
+
+    expect(shown).toBe(THREAD_LEADING_REPLIES + THREAD_TRAILING_REPLIES);
+    expect(fold?.hiddenCount).toBe(50 - shown);
+  });
+});
+
+describe("getThreadHiddenCount", () => {
+  // The site selects its buckets in SQL and they overlap on short threads, so
+  // the count has to dedupe rather than subtract two lengths.
+  it("counts a reply in two buckets once", () => {
+    expect(
+      getThreadHiddenCount({
+        leadingReplies: [reply(1), reply(2)],
+        trailingReplies: [reply(1)],
+        latestReply: reply(2),
+        totalReplyCount: 2,
+      }),
+    ).toBe(0);
+  });
+
+  it("counts what a long thread leaves out", () => {
+    expect(
+      getThreadHiddenCount({
+        leadingReplies: [reply(1), reply(2)],
+        trailingReplies: [reply(6), reply(7)],
+        latestReply: reply(8),
+        totalReplyCount: 8,
+      }),
+    ).toBe(3);
+  });
+
+  // A reply published between the count and the selection would otherwise
+  // report a negative number of hidden posts.
+  it("never goes below zero", () => {
+    expect(
+      getThreadHiddenCount({
+        leadingReplies: [reply(1), reply(2)],
+        trailingReplies: [],
+        latestReply: reply(3),
+        totalReplyCount: 1,
+      }),
+    ).toBe(0);
+  });
+});