@decocms/apps-blog 7.52.1 → 7.54.0

package/src/loaders/BlogPostItem.ts

@@ -1,8 +1,9 @@
 import { getRecordsByPath } from "../core/records";
 import type { BlogPost } from "../types";
+import { isLivePost } from "../types";
 
 export interface Props {
-	slug: string;
+  slug: string;
 }
 
 /**
@@ -11,9 +12,18 @@ export interface Props {
  * directly (not wrapped in BlogPostPage).
  */
 export default function BlogPostItem(props: Props & { __pageUrl?: string }): BlogPost | null {
-	const { slug } = props;
-	if (!slug) return null;
+  const { slug } = props;
+  if (!slug) return null;
 
-	const posts = getRecordsByPath<BlogPost>("collections/blog/posts", "post");
-	return posts.find((p) => p?.slug === slug) ?? null;
+  const posts = getRecordsByPath<BlogPost>("collections/blog/posts", "post");
+  const post = posts.find((p) => p?.slug === slug);
+
+  if (!post) return null;
+
+  // A post that isn't live yet — unpublished, or scheduled for an instant still
+  // ahead — is still served, because that page *is* the CMS preview. It just
+  // must never be indexed. Everything else the post declared under `seo` is
+  // kept as-is, and a scheduled post becomes indexable on its own once its
+  // instant passes.
+  return isLivePost(post) ? post : { ...post, seo: { ...post.seo, noIndexing: true } };
 }

package/src/loaders/BlogPostPage.ts

@@ -1,11 +1,12 @@
 import { getRecordsByPath } from "../core/records";
 import type { BlogPost, BlogPostPage } from "../types";
+import { isLivePost } from "../types";
 
 const COLLECTION_PATH = "collections/blog/posts";
 const ACCESSOR = "post";
 
 export interface Props {
-	slug: string;
+  slug: string;
 }
 
 /**
@@ -13,27 +14,31 @@ export interface Props {
  * @description Fetches a specific blog post page by its slug.
  */
 export default function BlogPostPageLoader(
-	props: Props & { __pageUrl?: string },
-	req?: Request,
+  props: Props & { __pageUrl?: string },
+  req?: Request,
 ): BlogPostPage | null {
-	const { slug } = props;
-	const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
+  const { slug } = props;
+  const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
 
-	const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
-	const url = new URL(rawUrl);
-	const post = posts.find((p) => p?.slug === slug);
+  const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
+  const url = new URL(rawUrl);
+  const post = posts.find((p) => p?.slug === slug);
 
-	if (!post) return null;
+  if (!post) return null;
 
-	return {
-		"@type": "BlogPostPage",
-		post,
-		seo: {
-			title: post?.seo?.title || post?.title,
-			description: post?.seo?.description || post?.excerpt,
-			canonical: post?.seo?.canonical || url.href,
-			image: post?.seo?.image || post?.image,
-			noIndexing: post?.seo?.noIndexing || false,
-		},
-	};
+  return {
+    "@type": "BlogPostPage",
+    post,
+    seo: {
+      title: post?.seo?.title || post?.title,
+      description: post?.seo?.description || post?.excerpt,
+      canonical: post?.seo?.canonical || url.href,
+      image: post?.seo?.image || post?.image,
+      // A post that isn't live yet — unpublished, or scheduled for an instant
+      // still ahead — renders anyway, because that page *is* the CMS preview.
+      // It just must never be indexed, even if the URL leaks. A scheduled post
+      // becomes indexable on its own once its instant passes.
+      noIndexing: post?.seo?.noIndexing || !isLivePost(post),
+    },
+  };
 }

package/src/loaders/BlogRelatedPosts.ts

@@ -6,35 +6,35 @@ const COLLECTION_PATH = "collections/blog/posts";
 const ACCESSOR = "post";
 
 export interface Props {
-	/**
-	 * @title Items per page
-	 * @description Number of posts per page to display.
-	 */
-	count?: number;
-	/**
-	 * @title Page query parameter
-	 * @description The current page number. Defaults to 1.
-	 */
-	page?: number;
-	/**
-	 * @title Category Slug
-	 * @description Filter by a specific category slug.
-	 */
-	slug?: string | string[];
-	/**
-	 * @title Page sorting parameter
-	 * @description The sorting option. Default is "date_desc"
-	 */
-	sortBy?: SortBy;
-	/**
-	 * @description Overrides the query term at url
-	 */
-	query?: string;
-	/**
-	 * @title Exclude Post Slug
-	 * @description Excludes a post slug from the list
-	 */
-	excludePostSlug?: string;
+  /**
+   * @title Items per page
+   * @description Number of posts per page to display.
+   */
+  count?: number;
+  /**
+   * @title Page query parameter
+   * @description The current page number. Defaults to 1.
+   */
+  page?: number;
+  /**
+   * @title Category Slug
+   * @description Filter by a specific category slug.
+   */
+  slug?: string | string[];
+  /**
+   * @title Page sorting parameter
+   * @description The sorting option. Default is "date_desc"
+   */
+  sortBy?: SortBy;
+  /**
+   * @description Overrides the query term at url
+   */
+  query?: string;
+  /**
+   * @title Exclude Post Slug
+   * @description Excludes a post slug from the list
+   */
+  excludePostSlug?: string;
 }
 
 export type BlogRelatedPosts = BlogPost[] | null;
@@ -43,24 +43,24 @@ export type BlogRelatedPosts = BlogPost[] | null;
  * @title BlogRelatedPosts
  * @description Retrieves a list of blog related posts.
  */
-export default function BlogRelatedPostsLoader(
-	props: Props & { __pageUrl?: string },
-	req?: Request,
-): BlogRelatedPosts {
-	const { page, count, slug, sortBy, query, excludePostSlug } = props;
-	const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
-	const url = new URL(rawUrl);
-	const postsPerPage = Number(count ?? url.searchParams.get("count") ?? 12);
-	const pageNumber = Number(page ?? url.searchParams.get("page") ?? 1);
-	const pageSort = sortBy ?? (url.searchParams.get("sortBy") as SortBy) ?? "date_desc";
-	const term = query ?? url.searchParams.get("q") ?? undefined;
+export default async function BlogRelatedPostsLoader(
+  props: Props & { __pageUrl?: string },
+  req?: Request,
+): Promise<BlogRelatedPosts> {
+  const { page, count, slug, sortBy, query, excludePostSlug } = props;
+  const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
+  const url = new URL(rawUrl);
+  const postsPerPage = Number(count ?? url.searchParams.get("count") ?? 12);
+  const pageNumber = Number(page ?? url.searchParams.get("page") ?? 1);
+  const pageSort = sortBy ?? (url.searchParams.get("sortBy") as SortBy) ?? "date_desc";
+  const term = query ?? url.searchParams.get("q") ?? undefined;
 
-	const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
+  const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
 
-	const handledPosts = handlePosts(posts, pageSort, slug, undefined, term, excludePostSlug);
+  const handledPosts = await handlePosts(posts, pageSort, slug, undefined, term, excludePostSlug);
 
-	if (!handledPosts) return null;
+  if (!handledPosts) return null;
 
-	const slicedPosts = slicePosts(handledPosts, pageNumber, postsPerPage);
-	return slicedPosts.length > 0 ? slicedPosts : null;
+  const slicedPosts = slicePosts(handledPosts, pageNumber, postsPerPage);
+  return slicedPosts.length > 0 ? slicedPosts : null;
 }

package/src/loaders/BlogpostList.ts

@@ -0,0 +1,73 @@
+import { logger, serializeError } from "@decocms/blocks/sdk/logger";
+import handlePosts, { slicePosts } from "../core/handlePosts";
+import { getRecordsByPath } from "../core/records";
+import type { BlogPost, SortBy } from "../types";
+
+const COLLECTION_PATH = "collections/blog/posts";
+const ACCESSOR = "post";
+
+export interface Props {
+  /**
+   * @title Items per page
+   * @description Number of posts per page to display.
+   */
+  count?: number;
+  /**
+   * @title Page query parameter
+   * @description The current page number. Defaults to 1.
+   */
+  page?: number;
+  /**
+   * @title Category Slug
+   * @description Filter by a specific category slug.
+   */
+  slug?: string;
+  /**
+   * @title Specific post slugs
+   * @description Filter by specific post slugs.
+   */
+  postSlugs?: string[];
+  /**
+   * @title Page sorting parameter
+   * @description The sorting option. Default is "date_desc"
+   */
+  sortBy?: SortBy;
+  /**
+   * @description Overrides the query term at url
+   */
+  query?: string;
+}
+
+/**
+ * @title BlogPostList
+ * @description Retrieves a flat list of blog posts.
+ */
+export default async function BlogPostList(
+  props: Props & { __pageUrl?: string },
+  req?: Request,
+): Promise<BlogPost[] | null> {
+  const { page, count, slug, sortBy, postSlugs, query } = props;
+  const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
+  const url = new URL(rawUrl);
+  const params = url.searchParams;
+  const postsPerPage = Number(count ?? params.get("count") ?? 12);
+  const pageNumber = Number(page ?? params.get("page") ?? 1);
+  const pageSort = sortBy ?? (params.get("sortBy") as SortBy) ?? "date_desc";
+  const term = query ?? params.get("q") ?? undefined;
+
+  const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
+
+  try {
+    const handledPosts = await handlePosts(posts, pageSort, slug, postSlugs, term);
+
+    if (!handledPosts) return null;
+
+    const slicedPosts = slicePosts(handledPosts, pageNumber, postsPerPage);
+
+    return slicedPosts.length > 0 ? slicedPosts : null;
+  } catch (e) {
+    const error = serializeError(e);
+    logger.error(error.message, { error, scope: "blog/BlogpostList" });
+    return null;
+  }
+}

package/src/loaders/BlogpostListing.ts

@@ -1,101 +1,138 @@
+import { logger, serializeError } from "@decocms/blocks/sdk/logger";
 import handlePosts, { slicePosts } from "../core/handlePosts";
 import { getRecordsByPath } from "../core/records";
-import type { BlogPost, BlogPostListingPage, PageInfo, SortBy } from "../types";
+import type { BlogPost, BlogPostListingPage, Category, PageInfo, SortBy } from "../types";
 
 const COLLECTION_PATH = "collections/blog/posts";
 const ACCESSOR = "post";
+const CATEGORIES_PATH = "collections/blog/categories";
+const CATEGORY_ACCESSOR = "category";
 
 export interface Props {
-	/**
-	 * @title Category Slug
-	 * @description Filter by a specific category slug.
-	 */
-	slug?: string;
-	/**
-	 * @title Items per page
-	 * @description Number of posts per page to display.
-	 */
-	count?: number;
-	/**
-	 * @title Page query parameter
-	 * @description The current page number. Defaults to 1.
-	 */
-	page?: number;
-	/**
-	 * @title Page sorting parameter
-	 * @description The sorting option. Default is "date_desc"
-	 */
-	sortBy?: SortBy;
-	/**
-	 * @description Overrides the query term at url
-	 */
-	query?: string;
+  /**
+   * @title Category Slug
+   * @description Filter by a specific category slug.
+   */
+  slug?: string;
+  /**
+   * @title Items per page
+   * @description Number of posts per page to display.
+   */
+  count?: number;
+  /**
+   * @title Page query parameter
+   * @description The current page number. Defaults to 1.
+   */
+  page?: number;
+  /**
+   * @title Page sorting parameter
+   * @description The sorting option. Default is "date_desc"
+   */
+  sortBy?: SortBy;
+  /**
+   * @description Overrides the query term at url
+   */
+  query?: string;
 }
 
+const report = (scope: string, e: unknown) => {
+  const error = serializeError(e);
+  logger.error(error.message, { error, scope });
+};
+
+/** Categories with a usable name and slug, alphabetically. */
+const loadCategories = (): Category[] =>
+  getRecordsByPath<Category>(CATEGORIES_PATH, CATEGORY_ACCESSOR)
+    .filter(
+      (c) =>
+        typeof c?.name === "string" &&
+        c.name.length > 0 &&
+        typeof c?.slug === "string" &&
+        c.slug.length > 0,
+    )
+    .sort((a, b) => a.name.localeCompare(b.name));
+
 /**
- * @title BlogPostList
- * @description Retrieves a paginated list of blog posts.
+ * @title BlogPostListing
+ * @description Retrieves a paginated listing page of blog posts.
  */
-export default function BlogPostList(
-	props: Props & { __pageUrl?: string },
-	req?: Request,
-): BlogPostListingPage | null {
-	const { page, count, slug, sortBy, query } = props;
-	const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
-	const url = new URL(rawUrl);
-	const params = url.searchParams;
-	const postsPerPage = Number(count ?? params.get("count") ?? 12);
-	const pageNumber = Number(page ?? params.get("page") ?? 1);
-	const pageSort = sortBy ?? (params.get("sortBy") as SortBy) ?? "date_desc";
-	const term = query ?? params.get("q") ?? undefined;
+export default async function BlogPostListing(
+  props: Props & { __pageUrl?: string },
+  req?: Request,
+): Promise<BlogPostListingPage | null> {
+  const { page, count, slug, sortBy, query } = props;
+  const rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
+  const url = new URL(rawUrl);
+  const params = url.searchParams;
+  const postsPerPage = Number(count ?? params.get("count") ?? 12);
+  const pageNumber = Number(page ?? params.get("page") ?? 1);
+  const pageSort = sortBy ?? (params.get("sortBy") as SortBy) ?? "date_desc";
+  const term = query ?? params.get("q") ?? undefined;
+
+  const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
 
-	const posts = getRecordsByPath<BlogPost>(COLLECTION_PATH, ACCESSOR);
+  try {
+    const handledPosts = await handlePosts(posts, pageSort, slug, undefined, term);
 
-	try {
-		const handledPosts = handlePosts(posts, pageSort, slug, undefined, term);
+    if (!handledPosts) return null;
 
-		if (!handledPosts) return null;
+    const slicedPosts = slicePosts(handledPosts, pageNumber, postsPerPage);
+    if (slicedPosts.length === 0) return null;
 
-		const slicedPosts = slicePosts(handledPosts, pageNumber, postsPerPage);
-		if (slicedPosts.length === 0) return null;
+    let categories: Category[] | null = null;
+    try {
+      categories = loadCategories();
+    } catch (e) {
+      report("blog/BlogpostListing/categories", e);
+    }
 
-		const category = slicedPosts[0].categories?.find((c) => c.slug === slug);
+    let category: Category | null = null;
+    if (slug) {
+      // Prefer the standalone category record (it carries description and
+      // sections); fall back to the denormalized copy embedded in a post,
+      // which is all a site that never created category records will have.
+      category = categories?.find((c) => c.slug === slug) ?? null;
+      category ??= slicedPosts[0]?.categories?.find((c) => c.slug === slug) ?? null;
+    }
 
-		return {
-			posts: slicedPosts,
-			pageInfo: toPageInfo(handledPosts, postsPerPage, pageNumber, params),
-			seo: {
-				title: category?.name ?? "",
-				canonical: new URL(url.pathname, url.origin).href,
-			},
-		};
-	} catch (e) {
-		console.error("[BlogpostListing]", e);
-		return null;
-	}
+    return {
+      posts: slicedPosts,
+      category,
+      categories,
+      pageInfo: toPageInfo(handledPosts, postsPerPage, pageNumber, params),
+      seo: {
+        title: category?.name ?? "",
+        description: category?.description,
+        canonical: new URL(url.pathname, url.origin).href,
+      },
+    };
+  } catch (e) {
+    report("blog/BlogpostListing", e);
+    return null;
+  }
 }
 
 function toPageInfo(
-	posts: BlogPost[],
-	postsPerPage: number,
-	pageNumber: number,
-	params: URLSearchParams,
+  posts: BlogPost[],
+  postsPerPage: number,
+  pageNumber: number,
+  params: URLSearchParams,
 ): PageInfo {
-	const totalPosts = posts.length;
-	const totalPages = Math.ceil(totalPosts / postsPerPage);
-	const hasNextPage = totalPages > pageNumber;
-	const hasPrevPage = pageNumber > 1;
-	const nextPage = new URLSearchParams(params);
-	const previousPage = new URLSearchParams(params);
+  const totalPosts = posts.length;
+  const totalPages = Math.ceil(totalPosts / postsPerPage);
+  const hasNextPage = totalPages > pageNumber;
+  const hasPrevPage = pageNumber > 1;
+  const nextPage = new URLSearchParams(params);
+  const previousPage = new URLSearchParams(params);
 
-	if (hasNextPage) nextPage.set("page", (pageNumber + 1).toString());
-	if (hasPrevPage) previousPage.set("page", (pageNumber - 1).toString());
+  if (hasNextPage) nextPage.set("page", (pageNumber + 1).toString());
+  if (hasPrevPage) previousPage.set("page", (pageNumber - 1).toString());
 
-	return {
-		nextPage: hasNextPage ? `?${nextPage}` : undefined,
-		previousPage: hasPrevPage ? `?${previousPage}` : undefined,
-		currentPage: pageNumber,
-		records: totalPosts,
-		recordPerPage: postsPerPage,
-	};
+  return {
+    nextPage: hasNextPage ? `?${nextPage}` : undefined,
+    previousPage: hasPrevPage ? `?${previousPage}` : undefined,
+    currentPage: pageNumber,
+    records: totalPosts,
+    recordPerPage: postsPerPage,
+  };
 }

package/src/loaders/GetCategories.ts

@@ -5,21 +5,21 @@ const COLLECTION_PATH = "collections/blog/categories";
 const ACCESSOR = "category";
 
 export interface Props {
-	/**
-	 * @title Category Slug
-	 * @description Get the category data from a specific slug.
-	 */
-	slug?: string;
-	/**
-	 * @title Items count
-	 * @description Number of categories to return
-	 */
-	count?: number;
-	/**
-	 * @title Sort
-	 * @description The sorting option. Default is "title_desc"
-	 */
-	sortBy?: "title_asc" | "title_desc";
+  /**
+   * @title Category Slug
+   * @description Get the category data from a specific slug.
+   */
+  slug?: string;
+  /**
+   * @title Items count
+   * @description Number of categories to return
+   */
+  count?: number;
+  /**
+   * @title Sort
+   * @description The sorting option. Default is "title_desc"
+   */
+  sortBy?: "title_asc" | "title_desc";
 }
 
 /**
@@ -27,22 +27,36 @@ export interface Props {
  * @description Retrieves a list of blog categories.
  */
 export default function GetCategories({
-	count,
-	slug,
-	sortBy = "title_desc",
+  count,
+  slug,
+  sortBy = "title_desc",
 }: Props): Category[] | null {
-	const categories = getRecordsByPath<Category>(COLLECTION_PATH, ACCESSOR);
+  const categories = getRecordsByPath<Category>(COLLECTION_PATH, ACCESSOR);
 
-	if (!categories?.length) return null;
+  if (!categories?.length) return null;
 
-	if (slug) {
-		return categories.filter((c) => c.slug === slug);
-	}
+  // Records come straight from the CMS, so name/slug are strings only by
+  // convention. A record missing either has no route and no label, so it would
+  // render as a blank chip linking nowhere — and would throw in the
+  // `localeCompare` sort below.
+  const validCategories = categories.filter(
+    (c) =>
+      typeof c?.name === "string" &&
+      c.name.length > 0 &&
+      typeof c?.slug === "string" &&
+      c.slug.length > 0,
+  );
 
-	const sortedCategories = categories.sort((a, b) => {
-		const comparison = a.name.localeCompare(b.name);
-		return sortBy.endsWith("_desc") ? comparison : -comparison;
-	});
+  if (slug) {
+    return validCategories.filter((c) => c.slug === slug);
+  }
 
-	return count ? sortedCategories.slice(0, count) : sortedCategories;
+  if (!validCategories.length) return null;
+
+  const sortedCategories = validCategories.sort((a, b) => {
+    const comparison = a.name.localeCompare(b.name);
+    return sortBy.endsWith("_desc") ? comparison : -comparison;
+  });
+
+  return count ? sortedCategories.slice(0, count) : sortedCategories;
 }

package/src/loaders/extensions/BlogpostList/ratings.ts

@@ -0,0 +1,36 @@
+import { getRatings } from "../../../core/records";
+import type { BlogPost, Ignore } from "../../../types";
+import type { ExtensionOf } from "../types";
+
+export interface Props {
+  /**
+   * @description Ignore ratings in the aggregateRating calc
+   */
+  ignoreRatings?: Ignore;
+  /**
+   * @description Return only aggregate rating object
+   */
+  onlyAggregate?: boolean;
+}
+
+/**
+ * @title ExtensionOf BlogPost list: Ratings
+ * @description It can harm performance. Use wisely
+ */
+export default function ratingsExt({
+  ignoreRatings,
+  onlyAggregate,
+}: Props): ExtensionOf<BlogPost[] | null> {
+  return async (posts: BlogPost[] | null) => {
+    if (!posts || posts.length === 0) {
+      return null;
+    }
+
+    return Promise.all(
+      posts.map(async (post) => {
+        const ratings = await getRatings({ post, ignoreRatings, onlyAggregate });
+        return { ...post, ...ratings };
+      }),
+    );
+  };
+}

package/src/loaders/extensions/BlogpostList/reviews.ts

@@ -0,0 +1,36 @@
+import { getReviews } from "../../../core/records";
+import type { BlogPost, Ignore } from "../../../types";
+import type { ExtensionOf } from "../types";
+
+export interface Props {
+  /**
+   * @description Ignore specific reviews
+   */
+  ignoreReviews?: Ignore;
+  /**
+   * @description Order By
+   */
+  orderBy?: "date_asc" | "date_desc";
+}
+
+/**
+ * @title ExtensionOf BlogPost list: Reviews
+ * @description It can harm performance. Use wisely
+ */
+export default function reviewsExt({
+  ignoreReviews,
+  orderBy,
+}: Props): ExtensionOf<BlogPost[] | null> {
+  return async (posts: BlogPost[] | null) => {
+    if (!posts || posts.length === 0) {
+      return null;
+    }
+
+    return Promise.all(
+      posts.map(async (post) => {
+        const reviews = await getReviews({ post, ignoreReviews, orderBy });
+        return { ...post, ...reviews };
+      }),
+    );
+  };
+}