@decocms/apps-blog 8.0.0 → 8.1.0-next.0

package/src/__tests__/loaders.test.ts

@@ -1,7 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("../core/records", () => ({
-	getRecordsByPath: vi.fn(),
+  getRecordsByPath: vi.fn(),
 }));
 
 import { getRecordsByPath } from "../core/records";
@@ -15,193 +15,237 @@ import type { BlogPost, Category } from "../types";
 const mockGetRecords = getRecordsByPath as ReturnType<typeof vi.fn>;
 
 function makePost(overrides: Partial<BlogPost> = {}): BlogPost {
-	return {
-		title: "Test Post",
-		slug: "test-post",
-		date: "2024-06-01",
-		excerpt: "A test post",
-		content: "Full content here",
-		categories: [{ name: "News", slug: "news" }],
-		authors: [{ name: "Author", email: "a@b.com" }],
-		...overrides,
-	};
+  return {
+    title: "Test Post",
+    slug: "test-post",
+    date: "2024-06-01",
+    excerpt: "A test post",
+    content: "Full content here",
+    categories: [{ name: "News", slug: "news" }],
+    authors: [{ name: "Author", email: "a@b.com" }],
+    ...overrides,
+  };
 }
 
 const samplePosts: BlogPost[] = [
-	makePost({ slug: "post-a", title: "Alpha", date: "2024-01-01" }),
-	makePost({ slug: "post-b", title: "Bravo", date: "2024-02-01" }),
-	makePost({ slug: "post-c", title: "Charlie", date: "2024-03-01" }),
+  makePost({ slug: "post-a", title: "Alpha", date: "2024-01-01" }),
+  makePost({ slug: "post-b", title: "Bravo", date: "2024-02-01" }),
+  makePost({ slug: "post-c", title: "Charlie", date: "2024-03-01" }),
 ];
 
 beforeEach(() => {
-	vi.clearAllMocks();
-	mockGetRecords.mockReturnValue(samplePosts);
+  vi.clearAllMocks();
+  mockGetRecords.mockReturnValue(samplePosts);
 });
 
 // ---------------------------------------------------------------------------
 // BlogpostListing
 // ---------------------------------------------------------------------------
 describe("BlogpostListing", () => {
-	it("returns paginated listing with defaults (page=1, count=12, sortBy=date_desc)", () => {
-		const result = BlogpostListing({});
-		expect(result).not.toBeNull();
-		expect(result!.posts).toHaveLength(3);
-		expect(result!.pageInfo.currentPage).toBe(1);
-		expect(result!.pageInfo.recordPerPage).toBe(12);
-		// date_desc: most recent first
-		expect(result!.posts[0].slug).toBe("post-c");
-	});
-
-	it("URL search params override props", () => {
-		const req = new Request("http://localhost/blog?page=2&count=1");
-		const result = BlogpostListing({}, req);
-		expect(result).not.toBeNull();
-		expect(result!.pageInfo.currentPage).toBe(2);
-		expect(result!.posts).toHaveLength(1);
-		expect(result!.posts[0].slug).toBe("post-b"); // second page of date_desc
-	});
-
-	it("computes nextPage / previousPage correctly", () => {
-		const result = BlogpostListing({ count: 1, page: 2 });
-		expect(result).not.toBeNull();
-		expect(result!.pageInfo.nextPage).toContain("page=3");
-		expect(result!.pageInfo.previousPage).toContain("page=1");
-	});
-
-	it("returns null when no posts match", () => {
-		mockGetRecords.mockReturnValue([]);
-		expect(BlogpostListing({})).toBeNull();
-	});
-
-	it("SEO canonical strips query params", () => {
-		const req = new Request("http://localhost/blog?page=1&count=1");
-		const result = BlogpostListing({}, req);
-		expect(result).not.toBeNull();
-		expect(result!.seo.canonical).toBe("http://localhost/blog");
-	});
+  it("returns paginated listing with defaults (page=1, count=12, sortBy=date_desc)", async () => {
+    const result = await BlogpostListing({});
+    expect(result).not.toBeNull();
+    expect(result!.posts).toHaveLength(3);
+    expect(result!.pageInfo.currentPage).toBe(1);
+    expect(result!.pageInfo.recordPerPage).toBe(12);
+    // date_desc: most recent first
+    expect(result!.posts[0].slug).toBe("post-c");
+  });
+
+  it("URL search params override props", async () => {
+    const req = new Request("http://localhost/blog?page=2&count=1");
+    const result = await BlogpostListing({}, req);
+    expect(result).not.toBeNull();
+    expect(result!.pageInfo.currentPage).toBe(2);
+    expect(result!.posts).toHaveLength(1);
+    expect(result!.posts[0].slug).toBe("post-b"); // second page of date_desc
+  });
+
+  it("computes nextPage / previousPage correctly", async () => {
+    const result = await BlogpostListing({ count: 1, page: 2 });
+    expect(result).not.toBeNull();
+    expect(result!.pageInfo.nextPage).toContain("page=3");
+    expect(result!.pageInfo.previousPage).toContain("page=1");
+  });
+
+  it("returns null when no posts match", async () => {
+    mockGetRecords.mockReturnValue([]);
+    expect(await BlogpostListing({})).toBeNull();
+  });
+
+  it("SEO canonical strips query params", async () => {
+    const req = new Request("http://localhost/blog?page=1&count=1");
+    const result = await BlogpostListing({}, req);
+    expect(result).not.toBeNull();
+    expect(result!.seo.canonical).toBe("http://localhost/blog");
+  });
 });
 
 // ---------------------------------------------------------------------------
 // BlogRelatedPosts
 // ---------------------------------------------------------------------------
 describe("BlogRelatedPostsLoader", () => {
-	it("excludes current post via excludePostSlug", () => {
-		const result = BlogRelatedPostsLoader({ excludePostSlug: "post-a" });
-		expect(result).not.toBeNull();
-		expect(result!.find((p) => p.slug === "post-a")).toBeUndefined();
-	});
-
-	it("returns BlogPost[] (not BlogPostListingPage)", () => {
-		const result = BlogRelatedPostsLoader({});
-		expect(Array.isArray(result)).toBe(true);
-	});
-
-	it("returns null when empty", () => {
-		mockGetRecords.mockReturnValue([]);
-		expect(BlogRelatedPostsLoader({})).toBeNull();
-	});
+  it("excludes current post via excludePostSlug", async () => {
+    const result = await BlogRelatedPostsLoader({ excludePostSlug: "post-a" });
+    expect(result).not.toBeNull();
+    expect(result!.find((p) => p.slug === "post-a")).toBeUndefined();
+  });
+
+  it("returns BlogPost[] (not BlogPostListingPage)", async () => {
+    const result = await BlogRelatedPostsLoader({});
+    expect(Array.isArray(result)).toBe(true);
+  });
+
+  it("returns null when empty", async () => {
+    mockGetRecords.mockReturnValue([]);
+    expect(await BlogRelatedPostsLoader({})).toBeNull();
+  });
+
+  // A post with no categories arrives here as `slug: []`. Answering the whole
+  // blog would turn "related posts" into a second listing of everything.
+  it("returns null for an empty category list, not every post", async () => {
+    expect(await BlogRelatedPostsLoader({ slug: [] })).toBeNull();
+  });
+
+  it("still relates on a non-empty category list", async () => {
+    mockGetRecords.mockReturnValue([
+      makePost({ slug: "in", categories: [{ name: "News", slug: "news" }] }),
+      makePost({ slug: "out", categories: [{ name: "Tech", slug: "tech" }] }),
+    ]);
+
+    const result = await BlogRelatedPostsLoader({ slug: ["news"] });
+    expect(result?.map((p) => p.slug)).toEqual(["in"]);
+  });
 });
 
 // ---------------------------------------------------------------------------
 // BlogPostPage
 // ---------------------------------------------------------------------------
 describe("BlogPostPageLoader", () => {
-	it("returns BlogPostPage with correct @type", () => {
-		const result = BlogPostPageLoader({ slug: "post-a" });
-		expect(result).not.toBeNull();
-		expect(result!["@type"]).toBe("BlogPostPage");
-		expect(result!.post.slug).toBe("post-a");
-	});
-
-	it("returns null when post not found", () => {
-		expect(BlogPostPageLoader({ slug: "nonexistent" })).toBeNull();
-	});
-
-	it("SEO fields fall back to post fields", () => {
-		mockGetRecords.mockReturnValue([
-			makePost({
-				slug: "no-seo",
-				title: "Fallback Title",
-				excerpt: "Fallback Desc",
-				image: "img.png",
-				seo: undefined,
-			}),
-		]);
-
-		const result = BlogPostPageLoader({ slug: "no-seo" });
-		expect(result).not.toBeNull();
-		expect(result!.seo?.title).toBe("Fallback Title");
-		expect(result!.seo?.description).toBe("Fallback Desc");
-		expect(result!.seo?.image).toBe("img.png");
-	});
-
-	it("uses SEO fields when present", () => {
-		mockGetRecords.mockReturnValue([
-			makePost({
-				slug: "has-seo",
-				title: "Post Title",
-				seo: { title: "SEO Title", description: "SEO Desc" },
-			}),
-		]);
-
-		const result = BlogPostPageLoader({ slug: "has-seo" });
-		expect(result!.seo?.title).toBe("SEO Title");
-		expect(result!.seo?.description).toBe("SEO Desc");
-	});
+  it("returns BlogPostPage with correct @type", () => {
+    const result = BlogPostPageLoader({ slug: "post-a" });
+    expect(result).not.toBeNull();
+    expect(result!["@type"]).toBe("BlogPostPage");
+    expect(result!.post.slug).toBe("post-a");
+  });
+
+  it("returns null when post not found", () => {
+    expect(BlogPostPageLoader({ slug: "nonexistent" })).toBeNull();
+  });
+
+  it("SEO fields fall back to post fields", () => {
+    mockGetRecords.mockReturnValue([
+      makePost({
+        slug: "no-seo",
+        title: "Fallback Title",
+        excerpt: "Fallback Desc",
+        image: "img.png",
+        seo: undefined,
+      }),
+    ]);
+
+    const result = BlogPostPageLoader({ slug: "no-seo" });
+    expect(result).not.toBeNull();
+    expect(result!.seo?.title).toBe("Fallback Title");
+    expect(result!.seo?.description).toBe("Fallback Desc");
+    expect(result!.seo?.image).toBe("img.png");
+  });
+
+  it("uses SEO fields when present", () => {
+    mockGetRecords.mockReturnValue([
+      makePost({
+        slug: "has-seo",
+        title: "Post Title",
+        seo: { title: "SEO Title", description: "SEO Desc" },
+      }),
+    ]);
+
+    const result = BlogPostPageLoader({ slug: "has-seo" });
+    expect(result!.seo?.title).toBe("SEO Title");
+    expect(result!.seo?.description).toBe("SEO Desc");
+  });
 });
 
 // ---------------------------------------------------------------------------
 // GetCategories
 // ---------------------------------------------------------------------------
 describe("GetCategories", () => {
-	const categories: Category[] = [
-		{ name: "Beta", slug: "beta" },
-		{ name: "Alpha", slug: "alpha" },
-		{ name: "Charlie", slug: "charlie" },
-	];
-
-	beforeEach(() => {
-		mockGetRecords.mockReturnValue([...categories]);
-	});
-
-	it("sorts by name (title_desc default)", () => {
-		const result = GetCategories({});
-		expect(result).not.toBeNull();
-		expect(result!.map((c) => c.name)).toEqual(["Alpha", "Beta", "Charlie"]);
-	});
-
-	it("filters by slug when provided", () => {
-		const result = GetCategories({ slug: "alpha" });
-		expect(result).toHaveLength(1);
-		expect(result![0].slug).toBe("alpha");
-	});
-
-	it("slices by count", () => {
-		const result = GetCategories({ count: 2 });
-		expect(result).toHaveLength(2);
-	});
-
-	it("returns null when no categories", () => {
-		mockGetRecords.mockReturnValue([]);
-		expect(GetCategories({})).toBeNull();
-	});
+  const categories: Category[] = [
+    { name: "Beta", slug: "beta" },
+    { name: "Alpha", slug: "alpha" },
+    { name: "Charlie", slug: "charlie" },
+  ];
+
+  beforeEach(() => {
+    mockGetRecords.mockReturnValue([...categories]);
+  });
+
+  it("sorts by name (title_desc default)", () => {
+    const result = GetCategories({});
+    expect(result).not.toBeNull();
+    expect(result!.map((c) => c.name)).toEqual(["Alpha", "Beta", "Charlie"]);
+  });
+
+  it("filters by slug when provided", () => {
+    const result = GetCategories({ slug: "alpha" });
+    expect(result).toHaveLength(1);
+    expect(result![0].slug).toBe("alpha");
+  });
+
+  it("slices by count", () => {
+    const result = GetCategories({ count: 2 });
+    expect(result).toHaveLength(2);
+  });
+
+  it("returns null when no categories", () => {
+    mockGetRecords.mockReturnValue([]);
+    expect(GetCategories({})).toBeNull();
+  });
+
+  describe("parentSlug", () => {
+    const nested: Category[] = [
+      { name: "Root", slug: "root" },
+      { name: "Zeta", slug: "zeta", parentSlug: "root" },
+      { name: "Alpha", slug: "alpha", parentSlug: "root" },
+      { name: "Deep", slug: "deep", parentSlug: "alpha" },
+    ];
+
+    beforeEach(() => {
+      mockGetRecords.mockReturnValue([...nested]);
+    });
+
+    it("returns only direct children, not the whole subtree", () => {
+      const result = GetCategories({ parentSlug: "root" });
+      expect(result!.map((c) => c.slug)).toEqual(["Alpha", "Zeta"].map((n) => n.toLowerCase()));
+    });
+
+    it("slices the scoped children by count", () => {
+      expect(GetCategories({ parentSlug: "root", count: 1 })!.map((c) => c.slug)).toEqual([
+        "alpha",
+      ]);
+    });
+
+    it("returns an empty list for a category with no children", () => {
+      expect(GetCategories({ parentSlug: "deep" })).toEqual([]);
+    });
+  });
 });
 
 // ---------------------------------------------------------------------------
 // BlogPostItem
 // ---------------------------------------------------------------------------
 describe("BlogPostItem", () => {
-	it("returns post by slug", () => {
-		const result = BlogPostItem({ slug: "post-b" });
-		expect(result).not.toBeNull();
-		expect(result!.slug).toBe("post-b");
-	});
-
-	it("returns null when no slug provided", () => {
-		expect(BlogPostItem({ slug: "" })).toBeNull();
-	});
-
-	it("returns null when post not found", () => {
-		expect(BlogPostItem({ slug: "nonexistent" })).toBeNull();
-	});
+  it("returns post by slug", () => {
+    const result = BlogPostItem({ slug: "post-b" });
+    expect(result).not.toBeNull();
+    expect(result!.slug).toBe("post-b");
+  });
+
+  it("returns null when no slug provided", () => {
+    expect(BlogPostItem({ slug: "" })).toBeNull();
+  });
+
+  it("returns null when post not found", () => {
+    expect(BlogPostItem({ slug: "nonexistent" })).toBeNull();
+  });
 });

package/src/__tests__/mod.test.ts

@@ -2,10 +2,10 @@ import { describe, expect, it } from "vitest";
 import { configure } from "../mod";
 
 describe("blog module", () => {
-	it("returns AppDefinition with name 'blog' and manifest", async () => {
-		const app = await configure({}, async () => null);
-		expect(app.name).toBe("blog");
-		expect(app.manifest).toBeDefined();
-		expect(app.state).toEqual({});
-	});
+  it("returns AppDefinition with name 'blog' and manifest", async () => {
+    const app = await configure({}, async () => null);
+    expect(app.name).toBe("blog");
+    expect(app.manifest).toBeDefined();
+    expect(app.state).toEqual({});
+  });
 });

package/src/__tests__/publicationStatus.test.ts

@@ -0,0 +1,176 @@
+/**
+ * The reason this package was re-synced from `deco-cx/apps`.
+ *
+ * Scope: the read-time publication gate — `isPublishedStatus` / `isLivePost`,
+ * `filterRoutablePosts`, and the fact that the gate runs *before* pagination so
+ * `count` yields `count` renderable posts. Also covers the counterpart on the
+ * detail loaders: a non-live post still renders (it is the CMS preview) but is
+ * marked `noIndexing`.
+ *
+ * Deliberately not covered here: the strict-parsing edge cases of
+ * `scheduledTime` (see `date.test.ts`) and anything requiring a records
+ * adapter (ratings/reviews/views).
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../core/records", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../core/records")>();
+  return { ...actual, getRecordsByPath: vi.fn() };
+});
+
+import handlePosts, { filterRoutablePosts } from "../core/handlePosts";
+import { getRecordsByPath } from "../core/records";
+import BlogPostItem from "../loaders/BlogPostItem";
+import BlogPostPageLoader from "../loaders/BlogPostPage";
+import BlogpostListing from "../loaders/BlogpostListing";
+import type { BlogPost, PostStatus } from "../types";
+import { isLivePost, isPublishedStatus } from "../types";
+
+const mockGetRecords = getRecordsByPath as ReturnType<typeof vi.fn>;
+
+const post = (overrides: Partial<BlogPost> = {}): BlogPost => ({
+  title: "Post",
+  slug: "post",
+  date: "2024-06-01",
+  excerpt: "excerpt",
+  ...overrides,
+});
+
+const HOUR = 60 * 60 * 1000;
+const iso = (offsetMs: number) => new Date(Date.now() + offsetMs).toISOString();
+
+describe("isPublishedStatus", () => {
+  it("treats an absent status as published — legacy records predate the field", () => {
+    expect(isPublishedStatus(undefined)).toBe(true);
+    expect(isPublishedStatus("")).toBe(true);
+  });
+
+  it("accepts only an explicit `published`", () => {
+    expect(isPublishedStatus("published")).toBe(true);
+    for (const status of ["draft", "scheduled", "archived", "generating", "awaiting_review"]) {
+      expect(isPublishedStatus(status)).toBe(false);
+    }
+  });
+
+  it("fails closed on a status this version does not know", () => {
+    expect(isPublishedStatus("some_future_state")).toBe(false);
+  });
+});
+
+describe("isLivePost", () => {
+  it("hides every non-published, non-scheduled status", () => {
+    const hidden: PostStatus[] = ["draft", "archived", "generating", "awaiting_review"];
+    for (const status of hidden) {
+      expect(isLivePost({ status })).toBe(false);
+    }
+  });
+
+  it("hides a scheduled post whose instant has not arrived", () => {
+    expect(isLivePost({ status: "scheduled", scheduledDatetime: iso(HOUR) })).toBe(false);
+  });
+
+  it("shows a scheduled post whose instant has passed", () => {
+    expect(isLivePost({ status: "scheduled", scheduledDatetime: iso(-HOUR) })).toBe(true);
+  });
+
+  it("hides a scheduled post with a missing or unreadable instant", () => {
+    expect(isLivePost({ status: "scheduled" })).toBe(false);
+    // Lenient `Date` would read this as the year 2000, i.e. already live.
+    expect(isLivePost({ status: "scheduled", scheduledDatetime: "0" })).toBe(false);
+    // Calendar overflow must be rejected, not rolled forward to March 3rd.
+    expect(isLivePost({ status: "scheduled", scheduledDatetime: "2020-02-31" })).toBe(false);
+  });
+
+  it("honours the epoch as a real instant", () => {
+    expect(isLivePost({ status: "scheduled", scheduledDatetime: "1970-01-01T00:00:00Z" })).toBe(
+      true,
+    );
+  });
+});
+
+describe("filterRoutablePosts", () => {
+  it("drops posts with no usable slug — they have no route to link to", () => {
+    const posts = [
+      post({ slug: "ok" }),
+      post({ slug: "" }),
+      post({ slug: "   " }),
+      post({ slug: undefined as unknown as string }),
+      post({ slug: 42 as unknown as string }),
+    ];
+    expect(filterRoutablePosts(posts).map((p) => p.slug)).toEqual(["ok"]);
+  });
+});
+
+describe("listing pagination applies the gate before slicing", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const mixed = [
+    post({ slug: "live-1", date: "2024-05-01" }),
+    post({ slug: "draft-1", date: "2024-04-01", status: "draft" }),
+    post({ slug: "generating-1", date: "2024-03-01", status: "generating" }),
+    post({
+      slug: "future-1",
+      date: "2024-02-01",
+      status: "scheduled",
+      scheduledDatetime: iso(HOUR),
+    }),
+    post({
+      slug: "past-1",
+      date: "2024-01-01",
+      status: "scheduled",
+      scheduledDatetime: iso(-HOUR),
+    }),
+  ];
+
+  it("handlePosts keeps only live posts", async () => {
+    const result = await handlePosts(mixed, "date_desc");
+    expect(result?.map((p) => p.slug)).toEqual(["live-1", "past-1"]);
+  });
+
+  it("count: 2 yields 2 renderable posts, not 2 records minus the hidden ones", async () => {
+    mockGetRecords.mockReturnValue(mixed);
+    const result = await BlogpostListing({ count: 2 });
+    expect(result).not.toBeNull();
+    // Without the gate running first, the page-1 slice would have been
+    // [live-1, draft-1] and rendered a single visible card.
+    expect(result?.posts.map((p) => p.slug)).toEqual(["live-1", "past-1"]);
+  });
+
+  it("returns null when every record is gated out", async () => {
+    mockGetRecords.mockReturnValue([post({ slug: "d", status: "draft" })]);
+    expect(await BlogpostListing({})).toBeNull();
+  });
+});
+
+describe("detail loaders serve non-live posts as previews, unindexed", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("BlogPostPage marks a draft noIndexing but still renders it", () => {
+    mockGetRecords.mockReturnValue([post({ slug: "d", status: "draft" })]);
+    const result = BlogPostPageLoader({ slug: "d" });
+    expect(result?.post.slug).toBe("d");
+    expect(result?.seo?.noIndexing).toBe(true);
+  });
+
+  it("BlogPostPage leaves a live post indexable", () => {
+    mockGetRecords.mockReturnValue([post({ slug: "p", status: "published" })]);
+    expect(BlogPostPageLoader({ slug: "p" })?.seo?.noIndexing).toBe(false);
+  });
+
+  it("BlogPostItem stamps noIndexing without discarding the post's own seo", () => {
+    mockGetRecords.mockReturnValue([post({ slug: "d", status: "draft", seo: { title: "Kept" } })]);
+    const result = BlogPostItem({ slug: "d" });
+    expect(result?.seo).toEqual({ title: "Kept", noIndexing: true });
+  });
+
+  it("BlogPostItem returns a live post untouched", () => {
+    const live = post({ slug: "p" });
+    mockGetRecords.mockReturnValue([live]);
+    expect(BlogPostItem({ slug: "p" })).toBe(live);
+  });
+});