@decocms/apps-blog 7.52.1 → 7.53.0

package/src/core/blogRecords.ts

@@ -0,0 +1,94 @@
+/**
+ * Injectable persistence port for the blog's ratings, reviews and view counts.
+ *
+ * In `deco-cx/apps` these three features talk to the separate `records` app —
+ * a Turso/libsql database driven through `drizzle-orm`, reached as
+ * `await ctx.invoke.records.loaders.drizzle()`. Neither that app nor drizzle
+ * exists in this monorepo, and adding them would make every site that installs
+ * the blog app carry a database client it probably doesn't use.
+ *
+ * So the dependency is inverted, the same way `@decocms/blocks-admin` inverts
+ * its KV dependency via `setFastDeployKVGetter`: this package declares the
+ * operations it needs, and the site injects an implementation at boot. The port
+ * is expressed as *domain* operations rather than as a query builder, so the
+ * table and column names stay on the site's side of the boundary — which is
+ * also why `db/schema.ts` is deliberately not ported.
+ *
+ * With no adapter registered every read degrades to empty and every write to
+ * `null`, mirroring what the Deno app does when the `records` app isn't
+ * installed. That's the common case: a blog with no comments or view counter
+ * works untouched.
+ */
+
+import type { Person } from "@decocms/apps-commerce/types";
+import type { Rating, Review, ViewFromDatabase } from "../types";
+
+export interface ListReviewsOptions {
+  slug: string;
+  /**
+   * `additionalType` values to exclude — the moderation states a site wants
+   * kept out of the public list.
+   */
+  excludeAdditionalTypes?: string[];
+  orderBy: "date_asc" | "date_desc";
+}
+
+export interface UpsertRatingInput {
+  itemReviewed: string;
+  author: Person;
+  ratingValue: number;
+  additionalType?: string;
+}
+
+export interface CreateReviewInput {
+  itemReviewed?: string;
+  author?: Person;
+  reviewHeadline?: string;
+  reviewBody?: string;
+  additionalType?: string;
+  isAnonymous?: boolean;
+  datePublished: string;
+  dateModified: string;
+}
+
+export interface UpdateReviewInput {
+  reviewHeadline?: string;
+  reviewBody?: string;
+  additionalType?: string;
+  dateModified: string;
+}
+
+/**
+ * Every method is optional: a site that only wants view counts implements
+ * `listPostViews`/`incrementPostView` and leaves the rest out.
+ */
+export interface BlogRecordsAdapter {
+  listRatings?(slug: string): Promise<Rating[]>;
+  /**
+   * Creates the rating, or replaces the value of this author's existing rating
+   * for the same item — one rating per author per post.
+   */
+  upsertRating?(input: UpsertRatingInput): Promise<Rating | null>;
+  listReviews?(options: ListReviewsOptions): Promise<Review[]>;
+  getReview?(id: string): Promise<Review | null>;
+  createReview?(input: CreateReviewInput): Promise<Review | null>;
+  updateReview?(id: string, patch: UpdateReviewInput): Promise<Review | null>;
+  listPostViews?(): Promise<ViewFromDatabase[]>;
+  /** Increments (or creates at 1) the view counter, returning the new total. */
+  incrementPostView?(id: string): Promise<{ count: number }>;
+}
+
+const G = globalThis as unknown as { __decoBlogRecordsAdapter?: BlogRecordsAdapter };
+
+/**
+ * Registers the persistence backend for ratings, reviews and view counts.
+ * Call once at boot, before any request is served.
+ */
+export function setBlogRecordsAdapter(adapter: BlogRecordsAdapter): void {
+  G.__decoBlogRecordsAdapter = adapter;
+}
+
+/** The registered adapter, or `undefined` when the site never injected one. */
+export function getBlogRecordsAdapter(): BlogRecordsAdapter | undefined {
+  return G.__decoBlogRecordsAdapter;
+}

package/src/core/handlePosts.ts

@@ -1,88 +1,179 @@
 import type { BlogPost, SortBy } from "../types";
-
-const VALID_SORT_ORDERS = ["asc", "desc"];
+import { isLivePost } from "../types";
+import { VALID_SORT_ORDERS } from "../utils/constants";
+import { dateToTime } from "../utils/date";
+import { getBlogRecordsAdapter } from "./blogRecords";
 
 /**
- * Sort posts by the given criteria.
- * Skips view-based sorting (no Drizzle in this port).
+ * Returns a sorted BlogPost list.
+ *
+ * @param blogPosts Posts to be sorted
+ * @param sortBy Sort option ("date_desc" | "date_asc" | "title_asc" | "title_desc" | "view_asc" | "view_desc")
  */
-export const sortPosts = (blogPosts: BlogPost[], sortBy: SortBy): BlogPost[] => {
-	const parts = sortBy.split("_");
-	const sortMethod = (parts[0] in blogPosts[0] ? parts[0] : "date") as keyof BlogPost;
-	const sortOrder = VALID_SORT_ORDERS.includes(parts[1]) ? parts[1] : "desc";
-
-	return [...blogPosts].sort((a, b) => {
-		if (!a[sortMethod] && !b[sortMethod]) return 0;
-		if (!a[sortMethod]) return 1;
-		if (!b[sortMethod]) return -1;
-
-		const comparison =
-			sortMethod === "date"
-				? new Date(`${b.date}T00:00:00`).getTime() - new Date(`${a.date}T00:00:00`).getTime()
-				: (a[sortMethod]?.toString().localeCompare(b[sortMethod]?.toString() ?? "") ?? 0);
-
-		return sortOrder === "desc" ? comparison : -comparison;
-	});
+export const sortPosts = async (blogPosts: BlogPost[], sortBy: SortBy): Promise<BlogPost[]> => {
+  const splittedSort = sortBy.split("_");
+
+  if (splittedSort[0] === "view") {
+    const views = await getBlogRecordsAdapter()?.listPostViews?.();
+
+    // No adapter (or no rows): fall through to the date sort rather than
+    // returning an arbitrary order. The Deno app threw here when the `records`
+    // app was missing; degrading is the deliberate difference — view sorting is
+    // an enhancement, and a blog without the backend should still render.
+    if (views?.length) {
+      // Act like a real extension: stamp the counts onto the posts.
+      for (const view of views) {
+        const post = blogPosts.find(({ slug }) => slug === view.id);
+        if (post) {
+          post.interactionStatistic = {
+            "@type": "InteractionCounter",
+            userInteractionCount: view.userInteractionCount,
+          };
+        }
+      }
+
+      const viewSortOrder = VALID_SORT_ORDERS.includes(splittedSort[1]) ? splittedSort[1] : "desc";
+
+      return [...blogPosts].sort((a, b) => {
+        const countOfA = a?.interactionStatistic?.userInteractionCount;
+        const countOfB = b?.interactionStatistic?.userInteractionCount;
+        if (!countOfA && !countOfB) {
+          return 0;
+        }
+        // NOTE: inverted, like the title branch below — `view_desc` puts the
+        // *least* viewed post first. Verbatim from upstream
+        // (deco-cx/apps blog/core/handlePosts.ts); only the `date` branch, which
+        // compares `b - a`, reads the right way round. Kept as-is so a site
+        // moving off the Deno app sees no reordering; fix it upstream first.
+        const comparison = (countOfA ?? 0) - (countOfB ?? 0);
+        return viewSortOrder === "desc" ? comparison : -comparison;
+      });
+    }
+  }
+
+  const sortMethod = (splittedSort[0] in blogPosts[0] ? splittedSort[0] : "date") as keyof BlogPost;
+  const sortOrder = VALID_SORT_ORDERS.includes(splittedSort[1]) ? splittedSort[1] : "desc";
+
+  return [...blogPosts].sort((a, b) => {
+    if (!a[sortMethod] && !b[sortMethod]) {
+      return 0; // Both lack the sort key — consider them equal
+    }
+    if (!a[sortMethod]) {
+      return 1; // a lacks the sort key — put it after b
+    }
+    if (!b[sortMethod]) {
+      return -1;
+    }
+    // NOTE: for the non-date keys this reads inverted — `title_asc` yields Z-A.
+    // That is upstream's behaviour (deco-cx/apps blog/core/handlePosts.ts) and
+    // existing content relies on it, so it is preserved here on purpose rather
+    // than "fixed" as a drive-by. Don't flip it without changing upstream too.
+    const comparison =
+      sortMethod === "date"
+        ? dateToTime(b.date) - dateToTime(a.date)
+        : (a[sortMethod]?.toString().localeCompare(b[sortMethod]?.toString() ?? "") ?? 0);
+    return sortOrder === "desc" ? comparison : -comparison;
+  });
 };
 
-/** Filter posts by a single category slug. */
+/**
+ * Returns a filtered BlogPost list.
+ *
+ * @param posts Posts to be handled
+ * @param slug Category slug to filter by
+ */
 export const filterPostsByCategory = (posts: BlogPost[], slug?: string): BlogPost[] =>
-	slug ? posts.filter(({ categories }) => categories?.find((c) => c.slug === slug)) : posts;
+  slug ? posts.filter(({ categories }) => categories?.find((c) => c.slug === slug)) : posts;
 
 /** Filter posts whose slug is in the given list. */
 export const filterPostsBySlugs = (posts: BlogPost[], postSlugs: string[]): BlogPost[] =>
-	posts.filter(({ slug }) => postSlugs.includes(slug));
+  posts.filter(({ slug }) => postSlugs.includes(slug));
 
 /** Filter posts matching a search term (title, excerpt, content). */
 export const filterPostsByTerm = (posts: BlogPost[], term: string): BlogPost[] =>
-	posts.filter(({ content, excerpt, title }) =>
-		[content, excerpt, title].some((field) => field?.toLowerCase().includes(term.toLowerCase())),
-	);
+  posts.filter(({ content, excerpt, title }) =>
+    [content, excerpt, title].some((field) => field?.toLowerCase().includes(term.toLowerCase())),
+  );
 
 /** Filter posts whose categories overlap with the given slug array. */
 export const filterRelatedPosts = (posts: BlogPost[], slugs: string[]): BlogPost[] =>
-	posts.filter(({ categories }) => categories?.find((c) => slugs.includes(c.slug)));
+  posts.filter(({ categories }) => categories?.find((c) => slugs.includes(c.slug)));
 
 /** Slice posts for pagination. */
 export const slicePosts = (
-	posts: BlogPost[],
-	pageNumber: number,
-	postsPerPage: number,
+  posts: BlogPost[],
+  pageNumber: number,
+  postsPerPage: number,
+): BlogPost[] => {
+  const startIndex = (pageNumber - 1) * postsPerPage;
+  return posts.slice(startIndex, startIndex + postsPerPage);
+};
+
+/**
+ * A record without a slug has no route, so it can never be rendered: listing it
+ * only produces cards linking to the listing itself. Posts that aren't live are
+ * unreachable for a different reason — either the CMS doesn't consider them
+ * ready, or they're scheduled for an instant that hasn't arrived yet — but the
+ * outcome is the same, so both are dropped here, before slicePosts, so `count`
+ * still yields `count` renderable posts.
+ *
+ * A scheduled post crossing its instant flips this filter on the next request
+ * that misses cache; nothing re-deploys and no record is rewritten.
+ */
+export const filterRoutablePosts = (posts: BlogPost[]): BlogPost[] =>
+  // Records come straight from the CMS, so `slug` is only a string by
+  // convention: the typeof guard keeps a malformed one from throwing here and
+  // taking the whole listing down with it.
+  posts.filter((post) => typeof post.slug === "string" && post.slug.trim() && isLivePost(post));
+
+const filterPosts = (
+  allPosts: BlogPost[],
+  slug?: string | string[],
+  postSlugs?: string[],
+  term?: string,
 ): BlogPost[] => {
-	const startIndex = (pageNumber - 1) * postsPerPage;
-	return posts.slice(startIndex, startIndex + postsPerPage);
+  const posts = filterRoutablePosts(allPosts);
+
+  if (typeof slug === "string") {
+    const firstFilter =
+      postSlugs && postSlugs.length > 0
+        ? filterPostsBySlugs(posts, postSlugs)
+        : filterPostsByCategory(posts, slug);
+
+    return term ? filterPostsByTerm(firstFilter, term) : firstFilter;
+  }
+  if (Array.isArray(slug)) {
+    return filterRelatedPosts(posts, slug);
+  }
+
+  return term ? filterPostsByTerm(posts, term) : posts;
 };
 
 /**
- * Combined filter & sort pipeline (no slice).
+ * Returns a filtered and sorted BlogPost list. It does not slice.
+ *
+ * @param posts Posts to be handled
+ * @param sortBy Sort option
+ * @param slug Category slug, or an array of slugs, to filter by
+ * @param postSlugs Specific slugs to filter by
+ * @param term Term to filter by
+ * @param excludePostSlug Slug to exclude
  */
-export default function handlePosts(
-	posts: BlogPost[],
-	sortBy: SortBy,
-	slug?: string | string[],
-	postSlugs?: string[],
-	term?: string,
-	excludePostSlug?: string,
-): BlogPost[] | null {
-	let filtered: BlogPost[];
-
-	if (typeof slug === "string") {
-		filtered =
-			postSlugs && postSlugs.length > 0
-				? filterPostsBySlugs(posts, postSlugs)
-				: filterPostsByCategory(posts, slug);
-		if (term) filtered = filterPostsByTerm(filtered, term);
-	} else if (Array.isArray(slug)) {
-		filtered = filterRelatedPosts(posts, slug);
-	} else {
-		filtered = term ? filterPostsByTerm(posts, term) : posts;
-	}
-
-	if (excludePostSlug) {
-		filtered = filtered.filter(({ slug: s }) => s !== excludePostSlug);
-	}
-
-	if (!filtered || filtered.length === 0) return null;
-
-	return sortPosts(filtered, sortBy);
+export default async function handlePosts(
+  posts: BlogPost[],
+  sortBy: SortBy,
+  slug?: string | string[],
+  postSlugs?: string[],
+  term?: string,
+  excludePostSlug?: string,
+): Promise<BlogPost[] | null> {
+  const filteredPosts = filterPosts(posts, slug, postSlugs, term).filter(
+    ({ slug: postSlug }) => postSlug !== excludePostSlug,
+  );
+
+  if (filteredPosts.length === 0) {
+    return null;
+  }
+
+  return sortPosts(filteredPosts, sortBy);
 }

package/src/core/records.ts

@@ -1,4 +1,7 @@
 import { loadBlocks } from "@decocms/blocks/cms";
+import { logger, serializeError } from "@decocms/blocks/sdk/logger";
+import type { BlogPost, Ignore, Rating, Review } from "../types";
+import { getBlogRecordsAdapter } from "./blogRecords";
 
 /**
  * Retrieve records from CMS blocks by path prefix.
@@ -10,21 +13,153 @@ import { loadBlocks } from "@decocms/blocks/cms";
  * `loadBlocks()` from `@decocms/blocks/cms` instead of `ctx.get(resolvables)`.
  */
 export function getRecordsByPath<T>(path: string, accessor: string): T[] {
-	const blocks = loadBlocks() as Record<string, Record<string, unknown>>;
-	const results: T[] = [];
+  const blocks = loadBlocks() as Record<string, Record<string, unknown>>;
+  const results: T[] = [];
 
-	for (const [key, value] of Object.entries(blocks)) {
-		if (!key.startsWith(path) || !value || typeof value !== "object") {
-			continue;
-		}
+  for (const [key, value] of Object.entries(blocks)) {
+    if (!key.startsWith(path) || !value || typeof value !== "object") {
+      continue;
+    }
 
-		const record = value[accessor] as T | undefined;
-		if (!record) continue;
+    const record = value[accessor] as T | undefined;
+    if (!record) continue;
 
-		const id = (value.name as string | undefined)?.split(path)[1]?.replace("/", "");
+    const id = (value.name as string | undefined)?.split(path)[1]?.replace("/", "");
 
-		results.push({ ...record, id } as T);
-	}
+    results.push({ ...record, id } as T);
+  }
 
-	return results;
+  return results;
+}
+
+const report = (scope: string, e: unknown) => {
+  const error = serializeError(e);
+  logger.error(error.message, { error, scope });
+};
+
+/**
+ * Ratings for one post, normalised with the rating scale.
+ *
+ * `bestRating`/`worstRating` are stamped here rather than stored, matching
+ * upstream: the scale is a property of this app's UI, not of the record.
+ */
+export async function getRatingsBySlug({ slug }: { slug: string }): Promise<Rating[]> {
+  try {
+    const currentRatings = await getBlogRecordsAdapter()?.listRatings?.(slug);
+
+    return (currentRatings ?? []).map((rating) => ({
+      ...rating,
+      bestRating: 5,
+      worstRating: 1,
+    }));
+  } catch (e) {
+    report("blog/getRatingsBySlug", e);
+    return [];
+  }
+}
+
+/** Returns the post enriched with its ratings and their aggregate. */
+export async function getRatings({
+  post,
+  ignoreRatings,
+  onlyAggregate,
+}: {
+  post: BlogPost;
+  ignoreRatings?: Ignore;
+  onlyAggregate?: boolean;
+}): Promise<BlogPost> {
+  const contentRating = await getRatingsBySlug({ slug: post.slug });
+
+  const { ratingCount, ratingTotal } =
+    contentRating.length === 0
+      ? { ratingCount: 0, ratingTotal: 0 }
+      : contentRating.reduce(
+          (acc, { ratingValue, additionalType }) =>
+            ignoreRatings?.active &&
+            additionalType &&
+            ignoreRatings.markedAs?.includes(additionalType)
+              ? acc
+              : {
+                  ratingCount: acc.ratingCount + 1,
+                  ratingTotal: acc.ratingTotal + (ratingValue ?? 0),
+                },
+          { ratingCount: 0, ratingTotal: 0 },
+        );
+
+  const ratingValue = ratingTotal / ratingCount;
+
+  return {
+    ...post,
+    contentRating: onlyAggregate ? undefined : contentRating,
+    aggregateRating: {
+      ...post.aggregateRating,
+      "@type": "AggregateRating",
+      ratingCount,
+      ratingValue: Number.isNaN(ratingValue) ? 0 : ratingValue,
+      bestRating: 5,
+      worstRating: 1,
+    },
+  };
+}
+
+export const getReviewById = async ({ id }: { id?: string }): Promise<Review | null> => {
+  if (!id) {
+    return null;
+  }
+  try {
+    return (await getBlogRecordsAdapter()?.getReview?.(id)) ?? null;
+  } catch (e) {
+    report("blog/getReviewById", e);
+    return null;
+  }
+};
+
+export async function getReviewsBySlug({
+  slug,
+  ignoreReviews,
+  orderBy = "date_desc",
+}: {
+  slug: string;
+  ignoreReviews?: Ignore;
+  orderBy?: "date_asc" | "date_desc";
+}): Promise<Review[]> {
+  const excludeAdditionalTypes =
+    ignoreReviews?.active && ignoreReviews.markedAs && ignoreReviews.markedAs.length > 0
+      ? ignoreReviews.markedAs
+      : undefined;
+
+  try {
+    const currentComments = await getBlogRecordsAdapter()?.listReviews?.({
+      slug,
+      excludeAdditionalTypes,
+      orderBy,
+    });
+
+    return currentComments ?? [];
+  } catch (e) {
+    report("blog/getReviewsBySlug", e);
+    return [];
+  }
+}
+
+/** Returns the post enriched with its reviews and their count. */
+export async function getReviews({
+  post,
+  ...rest
+}: {
+  post: BlogPost;
+  ignoreReviews?: Ignore;
+  orderBy?: "date_asc" | "date_desc";
+}): Promise<BlogPost> {
+  const review = await getReviewsBySlug({ slug: post.slug, ...rest });
+
+  return {
+    ...post,
+    review,
+    aggregateRating: {
+      ...post.aggregateRating,
+      "@type": "AggregateRating",
+      reviewCount: review.length,
+    },
+  };
 }

package/src/index.ts

@@ -1,24 +1,58 @@
 /**
  * Public API for the blog app.
+ *
+ * Subpath imports cover the rest of the surface:
+ * `@decocms/apps-blog/loaders/*`, `/actions/*`, `/sections/*`,
+ * `/sections/Seo/*`, `/sections/blocks/*`, `/utils/*`, `/core/*`,
+ * `/mod`, `/registry`, `/types`.
  */
 
+export { type BlogConfig, type BlogSeoDefaults, configureBlog, getBlogConfig } from "./client";
+export {
+  type BlogRecordsAdapter,
+  type CreateReviewInput,
+  getBlogRecordsAdapter,
+  type ListReviewsOptions,
+  setBlogRecordsAdapter,
+  type UpdateReviewInput,
+  type UpsertRatingInput,
+} from "./core/blogRecords";
 export { getRecordsByPath } from "./core/records";
-/** @deprecated Use `createBlogLoaders` instead. */
 export {
-	createBlogLoaders,
-	createBlogLoaders as createBlogCommerceLoaders,
+  createBlogLoaders,
+  /** @deprecated Use `createBlogLoaders` instead. */
+  createBlogLoaders as createBlogCommerceLoaders,
 } from "./loaderMap";
-export { configure } from "./mod";
-
+export { configure, handlers } from "./mod";
 // Types
 export type {
-	Author,
-	BlogPost,
-	BlogPostListingPage,
-	BlogPostPage,
-	Category,
-	ExtraProps,
-	PageInfo,
-	Seo,
-	SortBy,
+  AggregateRating,
+  Author,
+  Banner,
+  BannerItem,
+  BlogPost,
+  BlogPostListingPage,
+  BlogPostPage,
+  Category,
+  ExtraProps,
+  Ignore,
+  ImageCarousel,
+  InteractionCounter,
+  PageInfo,
+  PostStatus,
+  Publisher,
+  Rating,
+  Review,
+  Section,
+  Seo,
+  SortBy,
+  ViewFromDatabase,
 } from "./types";
+// Publication-status predicates — runtime exports, not just types: a site that
+// renders its own listing must apply the same liveness rule the loaders do.
+export { isLivePost, isPublishedStatus } from "./types";
+export { blocksToSections } from "./utils/blocksToSections";
+export { dateToTime, scheduledTime } from "./utils/date";
+export { hardSanitize } from "./utils/hardSanitize";
+export { toBlogPosting, toBreadcrumbList, toOrganization, withCanonicalBase } from "./utils/jsonLD";
+export { sanitizeHref, sanitizeHtml } from "./utils/sanitizeHtml";

package/src/loaderMap.ts

@@ -9,20 +9,24 @@ import AuthorLoader from "./loaders/Author";
 import BlogPostItemLoader from "./loaders/BlogPostItem";
 import BlogPostPageLoader from "./loaders/BlogPostPage";
 import BlogpostLoader from "./loaders/Blogpost";
+import BlogpostListLoader from "./loaders/BlogpostList";
 import BlogpostListingLoader from "./loaders/BlogpostListing";
 import BlogRelatedPostsLoader from "./loaders/BlogRelatedPosts";
 import CategoryLoader from "./loaders/Category";
 import GetCategoriesLoader from "./loaders/GetCategories";
 
-// biome-ignore lint/suspicious/noExplicitAny: loader props/returns vary per block
 export type LoaderFn = (props: any, request?: Request) => Promise<any> | any;
 
 /**
  * Create the blog loader map.
  *
+ * Each loader is registered under both key forms the resolver may see: the
+ * Deno app's `__resolveType` paths carry a `.ts` suffix, while manifest-derived
+ * keys do not.
+ *
  * @example
  * ```ts
- * import { createBlogLoaders } from "@decocms/apps/blog";
+ * import { createBlogLoaders } from "@decocms/apps-blog";
  *
  * const COMMERCE_LOADERS = {
  *   ...createVtexCommerceLoaders(),
@@ -31,27 +35,27 @@ export type LoaderFn = (props: any, request?: Request) => Promise<any> | any;
  * ```
  */
 export function createBlogLoaders(): Record<string, LoaderFn> {
-	return {
-		// Loader keys match the Deno app's __resolveType paths
-		"blog/loaders/BlogPostPage.ts": BlogPostPageLoader,
-		"blog/loaders/BlogPostPage": BlogPostPageLoader,
-		"blog/loaders/BlogpostListing.ts": BlogpostListingLoader,
-		"blog/loaders/BlogpostListing": BlogpostListingLoader,
-		"blog/loaders/BlogRelatedPosts.ts": BlogRelatedPostsLoader,
-		"blog/loaders/BlogRelatedPosts": BlogRelatedPostsLoader,
-		"blog/loaders/GetCategories.ts": GetCategoriesLoader,
-		"blog/loaders/GetCategories": GetCategoriesLoader,
-		"blog/loaders/Blogpost.ts": BlogpostLoader,
-		"blog/loaders/Blogpost": BlogpostLoader,
-		"blog/loaders/Category.ts": CategoryLoader,
-		"blog/loaders/Category": CategoryLoader,
-		"blog/loaders/Author.ts": AuthorLoader,
-		"blog/loaders/Author": AuthorLoader,
+  const byName: Record<string, LoaderFn> = {
+    "blog/loaders/BlogPostPage": BlogPostPageLoader,
+    "blog/loaders/BlogpostListing": BlogpostListingLoader,
+    // A distinct loader from BlogpostListing: it takes `postSlugs` and returns
+    // a flat BlogPost[] rather than a BlogPostListingPage. It used to be
+    // aliased to the listing loader here, which silently dropped `postSlugs`
+    // and handed callers the wrong shape.
+    "blog/loaders/BlogpostList": BlogpostListLoader,
+    "blog/loaders/BlogRelatedPosts": BlogRelatedPostsLoader,
+    "blog/loaders/GetCategories": GetCategoriesLoader,
+    "blog/loaders/Blogpost": BlogpostLoader,
+    "blog/loaders/Category": CategoryLoader,
+    "blog/loaders/Author": AuthorLoader,
+    // BlogPostItem: looks up a single post by slug, returns BlogPost
+    "blog/loaders/BlogPostItem": BlogPostItemLoader,
+  };
 
-		// BlogPostItem: looks up a single post by slug, returns BlogPost
-		"blog/loaders/BlogPostItem.ts": BlogPostItemLoader,
-		"blog/loaders/BlogPostItem": BlogPostItemLoader,
-		"blog/loaders/BlogpostList.ts": BlogpostListingLoader,
-		"blog/loaders/BlogpostList": BlogpostListingLoader,
-	};
+  return Object.fromEntries(
+    Object.entries(byName).flatMap(([key, fn]) => [
+      [key, fn],
+      [`${key}.ts`, fn],
+    ]),
+  );
 }