@unifiedcommerce/plugin-reviews 0.0.1

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+import type { customerReviews } from "./schema";
+export type { PluginDb as Db } from "@unifiedcommerce/core";
+export type Review = typeof customerReviews.$inferSelect;
+export type ReviewInsert = typeof customerReviews.$inferInsert;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD,YAAY,EAAE,QAAQ,IAAI,EAAE,EAAE,MAAM,uBAAuB,CAAC;AAC5D,MAAM,MAAM,MAAM,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACzD,MAAM,MAAM,YAAY,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@unifiedcommerce/plugin-reviews",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@hono/zod-openapi": "^1.2.2",
+    "@unifiedcommerce/core": "*",
+    "drizzle-orm": "^0.45.1",
+    "hono": "^4.12.5"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "@types/node": "^24.5.2",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import { defineCommercePlugin } from "@unifiedcommerce/core";
+import { customerReviews } from "./schema";
+import { ReviewService } from "./services/review-service";
+import { buildReviewRoutes } from "./routes/reviews";
+import type { Db } from "./types";
+
+export type { Db } from "./types";
+export { ReviewService } from "./services/review-service";
+
+export function reviewsPlugin() {
+  return defineCommercePlugin({
+    id: "reviews",
+    version: "1.0.0",
+    permissions: [
+      { scope: "reviews:admin", description: "Approve, reject, and reply to reviews." },
+      { scope: "reviews:write", description: "Submit reviews." },
+      { scope: "reviews:read", description: "View reviews and summaries." },
+    ],
+    schema: () => ({ customerReviews }),
+    hooks: () => [],
+    routes: (ctx) => {
+      const db = ctx.database.db as unknown as Db;
+      if (!db) return [];
+      return buildReviewRoutes(new ReviewService(db), ctx);
+    },
+  });
+}

package/src/routes/reviews.ts

@@ -0,0 +1,81 @@
+import { router } from "@unifiedcommerce/core";
+import { z } from "@hono/zod-openapi";
+import type { ReviewService } from "../services/review-service";
+import type { PluginRouteRegistration } from "@unifiedcommerce/core";
+
+export function buildReviewRoutes(
+  service: ReviewService,
+  ctx: { services?: Record<string, unknown>; database?: { db: unknown } },
+): PluginRouteRegistration[] {
+  const r = router("Reviews", "/reviews", ctx);
+
+  r.post("/").summary("Submit review").permission("reviews:write")
+    .input(z.object({
+      customerId: z.string().uuid().optional(),
+      entityId: z.string().uuid(),
+      orderId: z.string().uuid().optional(),
+      rating: z.number().int().min(1).max(5),
+      title: z.string().optional(),
+      body: z.string().optional(),
+    }))
+    .handler(async ({ input, orgId }) => {
+      const body = input as {
+        customerId?: string; entityId: string; orderId?: string;
+        rating: number; title?: string; body?: string;
+      };
+      const result = await service.submit(orgId, body);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/entity/{entityId}").summary("List reviews for entity").permission("reviews:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.listForEntity(orgId, params.entityId!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/entity/{entityId}/summary").summary("Review summary for entity").permission("reviews:read")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.getSummary(orgId, params.entityId!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.patch("/{id}/approve").summary("Approve review").permission("reviews:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.approve(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.patch("/{id}/reject").summary("Reject review").permission("reviews:admin")
+    .handler(async ({ params, orgId }) => {
+      const result = await service.reject(orgId, params.id!);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.post("/{id}/reply").summary("Reply to review").permission("reviews:admin")
+    .input(z.object({
+      response: z.string().min(1),
+      responseBy: z.string().min(1),
+    }))
+    .handler(async ({ params, input, orgId }) => {
+      const body = input as { response: string; responseBy: string };
+      const result = await service.reply(orgId, params.id!, body.response, body.responseBy);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  r.get("/mine").summary("My reviews").permission("reviews:write")
+    .handler(async ({ actor, orgId }) => {
+      // Use the authenticated actor's userId — never accept customerId from query
+      if (!actor?.userId) throw new Error("Authentication required");
+      const result = await service.listByCustomer(orgId, actor.userId);
+      if (!result.ok) throw new Error(result.error);
+      return result.value;
+    });
+
+  return r.routes();
+}

package/src/schema.ts

@@ -0,0 +1,26 @@
+import { pgTable, uuid, text, integer, boolean, timestamp, index } from "drizzle-orm/pg-core";
+
+export const customerReviews = pgTable("customer_reviews", {
+  id: uuid("id").defaultRandom().primaryKey(),
+  organizationId: text("organization_id").notNull(),
+  customerId: uuid("customer_id"),
+  entityId: uuid("entity_id").notNull(),
+  orderId: uuid("order_id"),
+  rating: integer("rating").notNull(),
+  title: text("title"),
+  body: text("body"),
+  status: text("status", { enum: ["pending", "approved", "rejected"] })
+    .notNull()
+    .default("pending"),
+  isVerified: boolean("is_verified").notNull().default(false),
+  isPublished: boolean("is_published").notNull().default(false),
+  response: text("response"),
+  responseBy: text("response_by"),
+  responseAt: timestamp("response_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+}, (table) => ({
+  orgIdx: index("idx_customer_reviews_org").on(table.organizationId),
+  entityIdx: index("idx_customer_reviews_entity").on(table.entityId),
+  statusIdx: index("idx_customer_reviews_status").on(table.status),
+}));

package/src/services/review-service.ts

@@ -0,0 +1,112 @@
+import { eq, and, sql } from "drizzle-orm";
+import { Ok, Err } from "@unifiedcommerce/core";
+import type { PluginResult } from "@unifiedcommerce/core";
+import { customerReviews } from "../schema";
+import type { Db, Review } from "../types";
+
+export interface ReviewSummary {
+  averageRating: number;
+  totalCount: number;
+  distribution: Record<number, number>;
+}
+
+export class ReviewService {
+  constructor(private db: Db) {}
+
+  async submit(orgId: string, input: {
+    customerId?: string;
+    entityId: string;
+    orderId?: string;
+    rating: number;
+    title?: string;
+    body?: string;
+  }): Promise<PluginResult<Review>> {
+    if (input.rating < 1 || input.rating > 5 || !Number.isInteger(input.rating)) {
+      return Err("Rating must be an integer between 1 and 5");
+    }
+    const isVerified = input.orderId != null;
+    const rows = await this.db.insert(customerReviews).values({
+      organizationId: orgId,
+      customerId: input.customerId ?? null,
+      entityId: input.entityId,
+      orderId: input.orderId ?? null,
+      rating: input.rating,
+      title: input.title ?? null,
+      body: input.body ?? null,
+      isVerified,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async listForEntity(orgId: string, entityId: string, publishedOnly?: boolean): Promise<PluginResult<Review[]>> {
+    const conditions = [
+      eq(customerReviews.organizationId, orgId),
+      eq(customerReviews.entityId, entityId),
+    ];
+    if (publishedOnly) {
+      conditions.push(eq(customerReviews.isPublished, true));
+    }
+    const rows = await this.db.select().from(customerReviews).where(and(...conditions));
+    return Ok(rows);
+  }
+
+  async getSummary(orgId: string, entityId: string): Promise<PluginResult<ReviewSummary>> {
+    const rows = await this.db.select({
+      rating: customerReviews.rating,
+      count: sql<number>`count(*)::int`,
+    })
+      .from(customerReviews)
+      .where(and(
+        eq(customerReviews.organizationId, orgId),
+        eq(customerReviews.entityId, entityId),
+      ))
+      .groupBy(customerReviews.rating);
+
+    const distribution: Record<number, number> = { 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 };
+    let totalCount = 0;
+    let totalSum = 0;
+    for (const row of rows) {
+      distribution[row.rating] = row.count;
+      totalCount += row.count;
+      totalSum += row.rating * row.count;
+    }
+    const averageRating = totalCount > 0 ? Math.round((totalSum / totalCount) * 100) / 100 : 0;
+    return Ok({ averageRating, totalCount, distribution });
+  }
+
+  async approve(orgId: string, id: string): Promise<PluginResult<Review>> {
+    const rows = await this.db.update(customerReviews)
+      .set({ status: "approved", isPublished: true, updatedAt: new Date() })
+      .where(and(eq(customerReviews.organizationId, orgId), eq(customerReviews.id, id)))
+      .returning();
+    if (rows.length === 0) return Err("Review not found");
+    return Ok(rows[0]!);
+  }
+
+  async reject(orgId: string, id: string): Promise<PluginResult<Review>> {
+    const rows = await this.db.update(customerReviews)
+      .set({ status: "rejected", isPublished: false, updatedAt: new Date() })
+      .where(and(eq(customerReviews.organizationId, orgId), eq(customerReviews.id, id)))
+      .returning();
+    if (rows.length === 0) return Err("Review not found");
+    return Ok(rows[0]!);
+  }
+
+  async reply(orgId: string, id: string, response: string, responseBy: string): Promise<PluginResult<Review>> {
+    const rows = await this.db.update(customerReviews)
+      .set({ response, responseBy, responseAt: new Date(), updatedAt: new Date() })
+      .where(and(eq(customerReviews.organizationId, orgId), eq(customerReviews.id, id)))
+      .returning();
+    if (rows.length === 0) return Err("Review not found");
+    return Ok(rows[0]!);
+  }
+
+  async listByCustomer(orgId: string, customerId: string): Promise<PluginResult<Review[]>> {
+    const rows = await this.db.select().from(customerReviews)
+      .where(and(
+        eq(customerReviews.organizationId, orgId),
+        eq(customerReviews.customerId, customerId),
+      ));
+    return Ok(rows);
+  }
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+import type { customerReviews } from "./schema";
+
+export type { PluginDb as Db } from "@unifiedcommerce/core";
+export type Review = typeof customerReviews.$inferSelect;
+export type ReviewInsert = typeof customerReviews.$inferInsert;