Feat blog comment

blog/actions/submitRating.ts

@@ -0,0 +1,75 @@
+import { and, eq, like, or } from "https://esm.sh/drizzle-orm@0.30.10";
+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/drizzle-orm@0.30.10";
+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

@@ -1,34 +1,25 @@
 import {
+  integer,
   sqliteTable,
   text,
 } from "https://esm.sh/drizzle-orm@0.30.10/sqlite-core";
-import { ArticleComment, Reaction } from "../types.ts";
 
-export const reactions = sqliteTable("reactions", {
+export const rating = sqliteTable("rating", {
   id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-  postSlug: text("postSlug").notNull(),
-  person: text("person", { mode: "json" }),
-  datePublished: (text("datePublished")).notNull(),
-  dateModified: (text("dateModified")).notNull(),
-  action: (text("action")).notNull(),
+  itemReviewed: text("itemReviewed").notNull(),
+  author: text("author", { mode: "json" }),
+  ratingValue: (integer("ratingValue")).notNull(),
+  additionalType: text("additionalType"),
 });
 
-export const comments = sqliteTable("comments", {
+export const review = sqliteTable("review", {
   id: text("id").primaryKey().$defaultFn(() => crypto.randomUUID()),
-  postSlug: text("postSlug").notNull(),
-  person: text("person", { mode: "json" }),
+  itemReviewed: text("itemReviewed").notNull(),
+  author: text("author", { mode: "json" }),
   datePublished: (text("datePublished")).notNull(),
   dateModified: (text("dateModified")).notNull(),
-  comment: (text("comment")).notNull(),
-  status: (text("status")).notNull(),
+  reviewHeadline: (text("reviewHeadline")),
+  reviewBody: (text("reviewBody")).notNull(),
+  additionalType: (text("additionalType")),
+  isAnonymous: integer("isAnonymous", { mode: "boolean" }),
 });
-
-export interface ReactionSchema extends Reaction {
-  id: string;
-  postSlug: string;
-}
-
-export interface CommentsSchema extends ArticleComment {
-  id: string;
-  postSlug: string;
-}