WIP - Blog extensions: Reviews and Ratings

blog/actions/submitRating.ts

@@ -0,0 +1,75 @@
+import { and, eq, like, or } from "https://esm.sh/[email protected]";
+import { Person } from "../../commerce/types.ts";
+import { AppContext } from "../mod.ts";
+import { logger } from "@deco/deco/o11y";
+import { Rating } from "../types.ts";
+import { rating } from "../db/schema.ts";
+
+export interface Props {
+  itemReviewed: string;
+  author: Person;
+  ratingValue: number;
+  additionalType?: string;
+}
+
+export default async function submitRating(
+  { itemReviewed, author, ratingValue, additionalType }: Props,
+  _req: Request,
+  ctx: AppContext,
+): Promise<Rating | null> {
+  const records = await ctx.invoke.records.loaders.drizzle();
+
+  try {
+    const storedRating = await records.select({
+      id: rating.id,
+      itemReviewed: rating.itemReviewed,
+      author: rating.author,
+      ratingValue: rating.ratingValue,
+      additionalType: rating.additionalType,
+    })
+      .from(rating).where(
+        and(
+          eq(rating.itemReviewed, itemReviewed),
+          or(
+            like(rating.author, `%"email":"${author.email}"%`),
+            like(rating.author, `%"id":"${author["@id"]}"%`),
+          ),
+        ),
+      ) as Rating[] | undefined;
+
+    //if has data, then update de table
+    if (storedRating && storedRating.length > 0 && storedRating?.at(0)?.id) {
+      const current = storedRating.at(0)!;
+      await records.update(rating).set({
+        ratingValue,
+        additionalType: additionalType ?? current.additionalType,
+      }).where(
+        eq(rating.id, current.id!),
+      );
+      return {
+        ...current,
+        ratingValue,
+        additionalType: additionalType ?? current.additionalType,
+      };
+    }
+
+    const insertedData = {
+      itemReviewed,
+      author: author!,
+      ratingValue: ratingValue!,
+      additionalType: additionalType,
+    };
+
+    await records.insert(rating).values({
+      ...insertedData,
+    });
+
+    return {
+      "@type": "Rating",
+      ...insertedData,
+    };
+  } catch (e) {
+    logger.error(e);
+    return null;
+  }
+}

blog/actions/submitReview.ts

@@ -0,0 +1,87 @@
+import { eq } from "https://esm.sh/[email protected]";
+import { Person } from "../../commerce/types.ts";
+import { AppContext } from "../mod.ts";
+import { logger } from "@deco/deco/o11y";
+import { Review } from "../types.ts";
+import { getReviewById } from "../core/records.ts";
+import { review } from "../db/schema.ts";
+
+export interface Props {
+  action: "create" | "update";
+  id?: string;
+  reviewBody?: string;
+  reviewHeadline?: string;
+  itemReviewed?: string;
+  author?: Person;
+  /** Review status */
+  additionalType?: string;
+  isAnonymous?: boolean;
+}
+
+export default async function submitReview(
+  {
+    reviewBody,
+    reviewHeadline,
+    itemReviewed,
+    id,
+    author,
+    action,
+    additionalType,
+    isAnonymous,
+  }: Props,
+  _req: Request,
+  ctx: AppContext,
+): Promise<Review | null> {
+  const isoDate = new Date().toISOString();
+  const records = await ctx.invoke.records.loaders.drizzle();
+
+  try {
+    if (action != "create") {
+      const storedReview = await getReviewById({ ctx, id });
+      if (!storedReview) {
+        return null;
+      }
+      const updateRecord = {
+        additionalType: additionalType ?? storedReview.additionalType,
+        reviewHeadline: reviewHeadline ?? storedReview.reviewHeadline,
+        reviewBody: reviewBody ?? storedReview.reviewBody,
+        dateModified: isoDate,
+      };
+      await records.update(review).set({
+        ...updateRecord,
+      }).where(
+        eq(review.id, id!),
+      );
+
+      return {
+        ...updateRecord,
+        "@type": "Review",
+        author: author ?? storedReview.author,
+        datePublished: storedReview.datePublished,
+      };
+    }
+
+    const insertData = {
+      itemReviewed,
+      isAnonymous,
+      author: author!,
+      additionalType: additionalType,
+      reviewHeadline: reviewHeadline,
+      reviewBody: reviewBody!,
+      datePublished: isoDate,
+      dateModified: isoDate,
+    };
+
+    await records.insert(review).values({
+      ...insertData,
+    });
+
+    return {
+      "@type": "Review",
+      ...insertData,
+    };
+  } catch (e) {
+    logger.error(e);
+    return null;
+  }
+}

blog/actions/submitView.ts

@@ -0,0 +1,38 @@
+import { eq } from "https://esm.sh/v135/[email protected]";
+import { postViews } from "../db/schema.ts";
+import { AppContext } from "../mod.ts";
+import { ViewFromDatabase } from "../types.ts";
+
+export interface Props {
+  id: string;
+}
+
+export default async function action(
+  { id }: Props,
+  _req: Request,
+  ctx: AppContext,
+): Promise<{ count: number }> {
+  const records = await ctx.invoke.records.loaders.drizzle();
+
+  const existingRecord = await records.select()
+    .from(postViews)
+    .where(eq(postViews.id, id))
+    .get() as ViewFromDatabase | null;
+
+  if (!existingRecord) {
+    await records.insert(postViews).values({
+      id,
+      userInteractionCount: 1,
+    });
+
+    return { count: 1 };
+  }
+
+  const newCount = existingRecord.userInteractionCount! + 1;
+
+  await records.update(postViews)
+    .set({ userInteractionCount: newCount })
+    .where(eq(postViews.id, id));
+
+  return { count: newCount };
+}

blog/utils/handlePosts.ts → blog/core/handlePosts.ts

@@ -1,15 +1,73 @@
-import { BlogPost, SortBy } from "../types.ts";
-import { VALID_SORT_ORDERS } from "./constants.ts";
+import { postViews } from "../db/schema.ts";
+import { AppContext } from "../mod.ts";
+import { BlogPost, SortBy, ViewFromDatabase } from "../types.ts";
+import { VALID_SORT_ORDERS } from "../utils/constants.ts";
 
 /**
  * Returns an sorted BlogPost list
  *
  * @param posts Posts to be sorted
- * @param sortBy Sort option (must be: "date_desc" | "date_asc" | "title_asc" | "title_desc" )
+ * @param sortBy Sort option (must be: "date_desc" | "date_asc" | "title_asc" | "title_desc" | "view_asc" | "view_desc" )
  */
-export const sortPosts = (blogPosts: BlogPost[], sortBy: SortBy) => {
+export const sortPosts = async (
+  blogPosts: BlogPost[],
+  sortBy: SortBy,
+  ctx: AppContext,
+) => {
   const splittedSort = sortBy.split("_");
 
+  if (splittedSort[0] === "view") {
+    //If sort is "view_asc" or "view_desc"
+
+    const records = await ctx.invoke.records.loaders.drizzle();
+    //Deco records not installed
+    if (records.__resolveType) {
+      throw new Error("Deco Records not installed!");
+    }
+
+    //Get views from database
+    const views = await records.select({
+      id: postViews.id,
+      userInteractionCount: postViews.userInteractionCount,
+    }).from(postViews) as ViewFromDatabase[] | null;
+
+    if (!views) {
+      return blogPosts;
+    }
+
+    //Act like a real extension
+    for (let i = 0; i < views.length; i++) {
+      const view = views[i];
+      const post = blogPosts.findIndex(({ slug }) => slug === view.id);
+
+      if (blogPosts[post]) {
+        blogPosts[post].interactionStatistic = {
+          "@type": "InteractionCounter",
+          userInteractionCount: view.userInteractionCount,
+        };
+      }
+    }
+
+    const sortOrder = VALID_SORT_ORDERS.includes(splittedSort[1])
+      ? splittedSort[1]
+      : "desc";
+
+    //Sort and return
+    return blogPosts.toSorted((a, b) => {
+      const countOfA = a?.interactionStatistic?.userInteractionCount;
+      const countOfB = b?.interactionStatistic?.userInteractionCount;
+      if (
+        !countOfA &&
+        !countOfB
+      ) {
+        return 0;
+      }
+
+      const comparison = (countOfA ?? 0) - (countOfB ?? 0);
+      return sortOrder === "desc" ? comparison : -comparison;
+    });
+  }
+
   const sortMethod = splittedSort[0] in blogPosts[0]
     ? splittedSort[0] as keyof BlogPost
     : "date";
@@ -69,12 +127,14 @@ export const slicePosts = (
  * Returns an filtered and sorted BlogPost list. It dont slice
  *
  * @param posts Posts to be handled
- * @param sortBy Sort option (must be: "date_desc" | "date_asc" | "title_asc" | "title_desc" )
+ * @param sortBy Sort option (must be: "date_desc" | "date_asc" | "title_asc" | "title_desc")
+ * @param ctx AppContext
  * @param slug Category slug to be filter
  */
-export default function handlePosts(
+export default async function handlePosts(
   posts: BlogPost[],
   sortBy: SortBy,
+  ctx: AppContext,
   slug?: string,
 ) {
   const filteredPosts = filterPostsByCategory(posts, slug);
@@ -83,5 +143,5 @@ export default function handlePosts(
     return null;
   }
 
-  return sortPosts(filteredPosts, sortBy);
+  return await sortPosts(filteredPosts, sortBy, ctx);
 }