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 "../utils/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/db/schema.ts

@@ -0,0 +1,25 @@
+import {
+  integer,
+  sqliteTable,
+  text,
+} from "https://esm.sh/[email protected]/sqlite-core";
+
+export const rating = sqliteTable("rating", {
+  id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+  itemReviewed: text("itemReviewed").notNull(),
+  author: text("author", { mode: "json" }),
+  ratingValue: (integer("ratingValue")).notNull(),
+  additionalType: text("additionalType"),
+});
+
+export const review = sqliteTable("review", {
+  id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
+  itemReviewed: text("itemReviewed").notNull(),
+  author: text("author", { mode: "json" }),
+  datePublished: (text("datePublished")).notNull(),
+  dateModified: (text("dateModified")).notNull(),
+  reviewHeadline: (text("reviewHeadline")),
+  reviewBody: (text("reviewBody")).notNull(),
+  additionalType: (text("additionalType")),
+  isAnonymous: integer("isAnonymous", { mode: "boolean" }),
+});

blog/loaders/extensions/BlogpostList.ts

@@ -0,0 +1,16 @@
+import {
+  default as extend,
+  Props,
+} from "../../../website/loaders/extension.ts";
+import { BlogPost } from "../../types.ts";
+
+/**
+ * @title Extend your Blogpost List
+ */
+export default function ProductDetailsExt(
+  props: Props<BlogPost[] | null>,
+): Promise<BlogPost[] | null> {
+  return extend(props);
+}
+
+export const cache = "no-cache";

blog/loaders/extensions/BlogpostList/ratings.ts

@@ -0,0 +1,45 @@
+import { ExtensionOf } from "../../../../website/loaders/extension.ts";
+import { AppContext } from "../../../mod.ts";
+import { BlogPost, Ignore } from "../../../types.ts";
+import { getRatings } from "../../../utils/records.ts";
+
+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,
+  _req: Request,
+  ctx: AppContext,
+): ExtensionOf<BlogPost[] | null> {
+  return async (posts: BlogPost[] | null) => {
+    if (posts?.length === 0 || !posts) {
+      return null;
+    }
+
+    const postsWithRatings = await Promise.all(
+      posts.map(async (post) => {
+        const ratings = await getRatings({
+          post,
+          ctx,
+          ignoreRatings,
+          onlyAggregate,
+        });
+        return { ...post, ...ratings };
+      }),
+    );
+
+    return postsWithRatings;
+  };
+}

blog/loaders/extensions/BlogpostList/reviews.ts

@@ -0,0 +1,40 @@
+import { ExtensionOf } from "../../../../website/loaders/extension.ts";
+import { AppContext } from "../../../mod.ts";
+import { BlogPost, Ignore } from "../../../types.ts";
+import { getReviews } from "../../../utils/records.ts";
+
+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,
+  _req: Request,
+  ctx: AppContext,
+): ExtensionOf<BlogPost[] | null> {
+  return async (posts: BlogPost[] | null) => {
+    if (posts?.length === 0 || !posts) {
+      return null;
+    }
+
+    const postsWithReviews = await Promise.all(
+      posts.map(async (post) => {
+        const reviews = await getReviews({ post, ctx, ignoreReviews, orderBy });
+        return { ...post, ...reviews };
+      }),
+    );
+
+    return postsWithReviews;
+  };
+}

blog/loaders/extensions/BlogpostListing.ts

@@ -0,0 +1,16 @@
+import {
+  default as extend,
+  Props,
+} from "../../../website/loaders/extension.ts";
+import { BlogPostListingPage } from "../../types.ts";
+
+/**
+ * @title Extend your Blogpost Listing Page
+ */
+export default function ProductDetailsExt(
+  props: Props<BlogPostListingPage | null>,
+): Promise<BlogPostListingPage | null> {
+  return extend(props);
+}
+
+export const cache = "no-cache";

blog/loaders/extensions/BlogpostListing/ratings.ts

@@ -0,0 +1,48 @@
+import { ExtensionOf } from "../../../../website/loaders/extension.ts";
+import { AppContext } from "../../../mod.ts";
+import { BlogPostListingPage, Ignore } from "../../../types.ts";
+import { getRatings } from "../../../utils/records.ts";
+
+interface Props {
+  /**
+   * @description Ignore ratings in the aggregateRating calc
+   */
+  ignoreRatings?: Ignore;
+  /**
+   * @description Return only aggregate rating object
+   */
+  onlyAggregate?: boolean;
+}
+
+/**
+ * @title ExtensionOf BlogPostListing: Ratings
+ * @description It can harm performance. Use wisely
+ */
+export default function ratingsExt(
+  { ignoreRatings, onlyAggregate }: Props,
+  _req: Request,
+  ctx: AppContext,
+): ExtensionOf<BlogPostListingPage | null> {
+  return async (blogpostListingPage: BlogPostListingPage | null) => {
+    if (!blogpostListingPage) {
+      return null;
+    }
+
+    const posts = await Promise.all(
+      blogpostListingPage.posts.map(async (post) => {
+        const ratings = await getRatings({
+          post,
+          ctx,
+          onlyAggregate,
+          ignoreRatings,
+        });
+        return { ...post, ...ratings };
+      }),
+    );
+
+    return {
+      ...blogpostListingPage,
+      posts,
+    };
+  };
+}