Automatically create bottles from reviews (#126)

apps/server/src/lib/bottleFinder.ts

@@ -1,6 +1,6 @@
 import { ilike, sql } from "drizzle-orm";
 import { db } from "../db";
-import { bottleAliases, bottles } from "../db/schema";
+import { bottleAliases, bottles, entities, type Entity } from "../db/schema";
 
 export async function findBottleId(name: string): Promise<number | null> {
   let result: { id: number | null } | null | undefined;
@@ -36,3 +36,14 @@ export async function findBottleId(name: string): Promise<number | null> {
 
   return result?.id || null;
 }
+
+export async function findEntity(fullName: string): Promise<Entity | null> {
+  const [result] = await db
+    .select()
+    .from(entities)
+    .where(sql`${entities.name} ~* ANY (string_to_array(${fullName}, ' '))`)
+    .orderBy(sql`LENGTH(${entities.name})`)
+    .limit(1);
+
+  return result ?? null;
+}

apps/server/src/schemas/reviews.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { CategoryEnum } from "./bottles";
 import { ExternalSiteSchema, ExternalSiteTypeEnum } from "./externalSites";
 
 export const ReviewSchema = z.object({
@@ -13,6 +14,7 @@ export const ReviewSchema = z.object({
 export const ReviewInputSchema = z.object({
   site: ExternalSiteTypeEnum,
   name: z.string().trim().min(1, "Required"),
+  category: CategoryEnum.nullable().optional(),
   rating: z.number(),
   issue: z.string().trim().min(1, "Required"),
   url: z.string().trim().min(1, "Required"),

apps/server/src/trpc/routes/reviewCreate.test.ts

@@ -0,0 +1,114 @@
+import { db } from "@peated/server/db";
+import * as Fixtures from "../../lib/test/fixtures";
+import { createCaller } from "../router";
+
+test("requires admin", async () => {
+  const site = await Fixtures.ExternalSite();
+
+  const caller = createCaller({
+    user: await Fixtures.User({ mod: true }),
+  });
+
+  expect(() =>
+    caller.reviewCreate({
+      site: site.type,
+      name: "Bottle Name",
+      issue: "Default",
+      rating: 89,
+      url: "https://example.com",
+      category: "single_malt",
+    }),
+  ).rejects.toThrowError(/UNAUTHORIZED/);
+});
+
+test("new review with new bottle no entity", async () => {
+  const site = await Fixtures.ExternalSite();
+
+  const caller = createCaller({
+    user: await Fixtures.User({ admin: true }),
+  });
+
+  const data = await caller.reviewCreate({
+    site: site.type,
+    name: "Bottle Name",
+    issue: "Default",
+    rating: 89,
+    url: "https://example.com",
+    category: "single_malt",
+  });
+
+  const review = await db.query.reviews.findFirst({
+    where: (table, { eq }) => eq(table.id, data.id),
+  });
+  expect(review).toBeDefined();
+  expect(review?.bottleId).toBeNull();
+  expect(review?.name).toEqual("Bottle Name");
+  expect(review?.issue).toEqual("Default");
+  expect(review?.rating).toEqual(89);
+  expect(review?.url).toEqual("https://example.com");
+});
+
+test("new review with new bottle matching entity", async () => {
+  const site = await Fixtures.ExternalSite();
+  const brand = await Fixtures.Entity();
+
+  const caller = createCaller({
+    user: await Fixtures.User({ admin: true }),
+  });
+
+  const data = await caller.reviewCreate({
+    site: site.type,
+    name: `${brand.name} Bottle Name`,
+    issue: "Default",
+    rating: 89,
+    url: "https://example.com",
+    category: "single_malt",
+  });
+
+  const review = await db.query.reviews.findFirst({
+    where: (table, { eq }) => eq(table.id, data.id),
+  });
+  expect(review).toBeDefined();
+  expect(review?.bottleId).toBeTruthy();
+  expect(review?.name).toEqual(`${brand.name} Bottle Name`);
+  expect(review?.issue).toEqual("Default");
+  expect(review?.rating).toEqual(89);
+  expect(review?.url).toEqual("https://example.com");
+
+  const bottle = await db.query.bottles.findFirst({
+    where: (table, { eq }) => eq(table.id, review!.bottleId as number),
+  });
+  expect(bottle).toBeDefined();
+  expect(bottle?.fullName).toEqual(`${brand.name} Bottle Name`);
+  expect(bottle?.name).toEqual("Bottle Name");
+  expect(bottle?.category).toEqual("single_malt");
+  expect(bottle?.brandId).toEqual(brand.id);
+});
+
+test("new review with existing bottle", async () => {
+  const site = await Fixtures.ExternalSite();
+  const bottle = await Fixtures.Bottle();
+
+  const caller = createCaller({
+    user: await Fixtures.User({ admin: true }),
+  });
+
+  const data = await caller.reviewCreate({
+    site: site.type,
+    name: bottle.fullName,
+    issue: "Default",
+    rating: 89,
+    url: "https://example.com",
+    category: bottle.category,
+  });
+
+  const review = await db.query.reviews.findFirst({
+    where: (table, { eq }) => eq(table.id, data.id),
+  });
+  expect(review).toBeDefined();
+  expect(review?.bottleId).toEqual(bottle.id);
+  expect(review?.name).toEqual(bottle.fullName);
+  expect(review?.issue).toEqual("Default");
+  expect(review?.rating).toEqual(89);
+  expect(review?.url).toEqual("https://example.com");
+});

apps/server/src/trpc/routes/reviewCreate.ts

@@ -4,13 +4,14 @@ import {
   externalSites,
   reviews,
 } from "@peated/server/db/schema";
-import { findBottleId } from "@peated/server/lib/bottleFinder";
+import { findBottleId, findEntity } from "@peated/server/lib/bottleFinder";
 import { ReviewInputSchema } from "@peated/server/schemas";
 import { serialize } from "@peated/server/serializers";
 import { ReviewSerializer } from "@peated/server/serializers/review";
 import { TRPCError } from "@trpc/server";
 import { eq, isNull, sql } from "drizzle-orm";
 import { adminProcedure } from "..";
+import { createCaller } from "../router";
 
 export default adminProcedure
   .input(ReviewInputSchema)
@@ -26,7 +27,20 @@ export default adminProcedure
       });
     }
 
-    const bottleId = await findBottleId(input.name);
+    let bottleId = await findBottleId(input.name);
+    if (!bottleId) {
+      const entity = await findEntity(input.name);
+      if (entity) {
+        const caller = createCaller(ctx);
+        const result = await caller.bottleCreate({
+          name: input.name,
+          brand: entity.id,
+          category: input.category,
+        });
+        bottleId = result.id;
+      }
+    }
+
     const review = await db.transaction(async (tx) => {
       const [review] = await tx
         .insert(reviews)