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

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],
+    ]),
+  );
 }

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,16 @@
+import { logger, serializeError } from "@decocms/blocks/sdk/logger";
+import { ancestorsOf, indexCategories, withCategoryPath } from "../core/categoryTree";
 import { getRecordsByPath } from "../core/records";
-import type { BlogPost, BlogPostPage } from "../types";
+import type { BlogPost, BlogPostPage, Category } from "../types";
+import { isLivePost } from "../types";
 
 const COLLECTION_PATH = "collections/blog/posts";
 const ACCESSOR = "post";
+const CATEGORIES_PATH = "collections/blog/categories";
+const CATEGORY_ACCESSOR = "category";
 
 export interface Props {
-	slug: string;
+  slug: string;
 }
 
 /**
@@ -13,27 +18,59 @@ 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 rawUrl = req?.url ?? props.__pageUrl ?? "http://localhost/";
-	const url = new URL(rawUrl);
-	const post = posts.find((p) => p?.slug === slug);
-
-	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,
-		},
-	};
+  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);
+
+  if (!post) return null;
+
+  // The post lives under the full path of its primary category, so the
+  // breadcrumb and the canonical need that category's ancestor chain. A broken
+  // categories collection must not take the post page down with it.
+  let categories: Category[] = [];
+  try {
+    categories = getRecordsByPath<Category>(CATEGORIES_PATH, CATEGORY_ACCESSOR) ?? [];
+  } catch (e) {
+    const error = serializeError(e);
+    logger.error(error.message, { error, scope: "blog/BlogPostPage/categories" });
+  }
+
+  const primarySlug = post.categories?.[0]?.slug;
+  const chain =
+    typeof primarySlug === "string" && primarySlug
+      ? ancestorsOf(primarySlug, indexCategories(categories))
+      : null;
+
+  // Only a chain that came out of the records is trustworthy enough to name a
+  // canonical URL; withCategoryPath itself returns null when the route has no
+  // category segment to replace, so a /blog/:slug site keeps its own URL.
+  const canonical = chain
+    ? withCategoryPath(url, chain, {
+        knownSlugs: new Set(categories.map((c) => c?.slug)),
+        trailing: post.slug,
+      })
+    : null;
+
+  return {
+    "@type": "BlogPostPage",
+    post,
+    categories: chain ?? (post.categories?.[0] ? [post.categories[0]] : null),
+    seo: {
+      title: post?.seo?.title || post?.title,
+      description: post?.seo?.description || post?.excerpt,
+      canonical: post?.seo?.canonical || 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,93 @@
+import { logger, serializeError } from "@decocms/blocks/sdk/logger";
+import { descendantSlugs } from "../core/categoryTree";
+import handlePosts, { slicePosts } from "../core/handlePosts";
+import { getRecordsByPath } from "../core/records";
+import type { BlogPost, Category, 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 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 category slug. May be a full path
+   * ("parent/child"); posts of every subcategory below the last segment are
+   * included.
+   */
+  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 {
+    // A parent category also lists its descendants' posts, so the slug expands
+    // into the whole subtree below it.
+    const leafSlug = (slug ?? "").split("/").filter(Boolean).pop();
+    let categorySlugs: string | string[] | undefined = leafSlug;
+
+    if (leafSlug && !postSlugs?.length) {
+      try {
+        const categories = getRecordsByPath<Category>(CATEGORIES_PATH, CATEGORY_ACCESSOR);
+        categorySlugs = descendantSlugs(leafSlug, categories);
+      } catch (e) {
+        const error = serializeError(e);
+        logger.error(error.message, { error, scope: "blog/BlogpostList/categories" });
+      }
+    }
+
+    const handledPosts = await handlePosts(posts, pageSort, categorySlugs, 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;
+  }
+}