@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/features/reviews/repository/__tests__/reviews.repository.test.js

@@ -0,0 +1,327 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery } = makeMockDb();
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+    };
+});
+vi.mock("../../../../security", () => ({
+    encryptPiiFields: (d) => d,
+    decryptPiiFields: (d) => d,
+    addPiiIndices: (d) => d,
+    REVIEW_PII_FIELDS: ["userName", "userEmail"],
+    REVIEW_PII_INDEX_MAP: {},
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { ReviewRepository } from "../reviews.repository";
+const repo = new ReviewRepository();
+function makeReviewDoc(overrides = {}) {
+    return {
+        id: "review-charizard-ravi-20260101",
+        productId: "product-charizard",
+        productTitle: "Charizard PSA9",
+        userId: "user-ravi",
+        userName: "Ravi Kumar",
+        storeId: "store-pokemon-palace",
+        rating: 5,
+        title: "Amazing card!",
+        body: "Pristine condition.",
+        status: "approved",
+        helpfulCount: 0,
+        reportCount: 0,
+        verified: true,
+        featured: false,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+function makeQueryDocSnaps(ratings, statusOverride = "approved") {
+    return ratings.map((rating, i) => ({
+        id: `review-${i}`,
+        data: makeReviewDoc({ id: `review-${i}`, rating, status: statusOverride }),
+    }));
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.orderBy.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.create", () => {
+    it("creates review with status: pending", async () => {
+        const input = {
+            productId: "product-charizard",
+            productTitle: "Charizard PSA9",
+            userId: "user-ravi",
+            userName: "Ravi Kumar",
+            storeId: "store-pokemon",
+            rating: 5,
+            title: "Great!",
+            body: "Excellent.",
+            images: [],
+        };
+        const result = await repo.create(input);
+        expect(result.status).toBe("pending");
+    });
+    it("starts helpfulCount at 0 and reportCount at 0", async () => {
+        const result = await repo.create({
+            productId: "p-1",
+            productTitle: "Hot Wheels",
+            userId: "user-1",
+            userName: "Arun",
+            storeId: "store-1",
+            rating: 4,
+            title: "Good",
+            body: "Nice toy",
+            images: [],
+        });
+        expect(result.helpfulCount).toBe(0);
+        expect(result.reportCount).toBe(0);
+    });
+    it("sets verified: false by default", async () => {
+        const result = await repo.create({
+            productId: "p-1",
+            productTitle: "T",
+            userId: "u-1",
+            userName: "User",
+            storeId: "s-1",
+            rating: 3,
+            title: "T",
+            body: "B",
+            images: [],
+        });
+        expect(result.verified).toBe(false);
+    });
+    it("persists the review to Firestore", async () => {
+        await repo.create({
+            productId: "p-1",
+            productTitle: "Product",
+            userId: "u-1",
+            userName: "User",
+            storeId: "s-1",
+            rating: 5,
+            title: "T",
+            body: "B",
+            images: [],
+        });
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// approve
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.approve", () => {
+    it("sets status: approved", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.approve("review-1", "mod-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "approved" }));
+    });
+    it("stores moderatorId on the review", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.approve("review-1", "mod-admin-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ moderatorId: "mod-admin-1" }));
+    });
+    it("sets approvedAt timestamp", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.approve("review-1", "mod-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ approvedAt: expect.any(Date) }));
+    });
+    it("stores optional moderatorNote when provided", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.approve("review-1", "mod-1", "Looks good");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ moderatorNote: "Looks good" }));
+    });
+});
+// ---------------------------------------------------------------------------
+// reject
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.reject", () => {
+    it("sets status: rejected", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.reject("review-1", "mod-1", "Spam content");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "rejected" }));
+    });
+    it("stores rejectionReason", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.reject("review-1", "mod-1", "Inappropriate language");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ rejectionReason: "Inappropriate language" }));
+    });
+    it("sets rejectedAt timestamp", async () => {
+        const review = makeReviewDoc({ status: "pending" });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.reject("review-1", "mod-1", "reason");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ rejectedAt: expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// incrementHelpful
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.incrementHelpful", () => {
+    it("increments helpfulCount by exactly 1", async () => {
+        const review = makeReviewDoc({ helpfulCount: 4 });
+        mockDocRef.get.mockResolvedValue(makeSnap(review, review.id));
+        await repo.incrementHelpful("review-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ helpfulCount: 5 }));
+    });
+    it("no-op when review is not found", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        await repo.incrementHelpful("review-ghost");
+        expect(mockDocRef.update).not.toHaveBeenCalled();
+    });
+});
+// ---------------------------------------------------------------------------
+// getAverageRating
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.getAverageRating", () => {
+    it("computes average from approved reviews", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([5, 3, 4])));
+        const avg = await repo.getAverageRating("product-charizard");
+        expect(avg).toBeCloseTo(4.0, 5);
+    });
+    it("single review → returns that rating exactly", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([3])));
+        const avg = await repo.getAverageRating("product-1");
+        expect(avg).toBe(3);
+    });
+    it("no reviews → returns 0", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const avg = await repo.getAverageRating("product-empty");
+        expect(avg).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// getRatingDistribution
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.getRatingDistribution", () => {
+    it("counts each rating bucket correctly", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([5, 5, 3])));
+        const dist = await repo.getRatingDistribution("product-1");
+        expect(dist[5]).toBe(2);
+        expect(dist[3]).toBe(1);
+    });
+    it("returns zeros for buckets with no reviews", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([5, 5, 3])));
+        const dist = await repo.getRatingDistribution("product-1");
+        expect(dist[1]).toBe(0);
+        expect(dist[2]).toBe(0);
+        expect(dist[4]).toBe(0);
+    });
+    it("all 5 ratings present", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([1, 2, 3, 4, 5])));
+        const dist = await repo.getRatingDistribution("product-1");
+        expect(dist[1]).toBe(1);
+        expect(dist[2]).toBe(1);
+        expect(dist[3]).toBe(1);
+        expect(dist[4]).toBe(1);
+        expect(dist[5]).toBe(1);
+    });
+    it("no reviews → all buckets are 0", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const dist = await repo.getRatingDistribution("product-empty");
+        expect(Object.values(dist).every((v) => v === 0)).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// getApprovedRatingAggregate
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.getApprovedRatingAggregate", () => {
+    it("returns count and avgRating rounded to 1 decimal", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([5, 4, 3])));
+        const agg = await repo.getApprovedRatingAggregate("product-1");
+        expect(agg.count).toBe(3);
+        expect(agg.avgRating).toBe(4.0);
+    });
+    it("avgRating correctly rounds to 1 decimal (3.333... → 3.3)", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap(makeQueryDocSnaps([4, 3, 3])));
+        const agg = await repo.getApprovedRatingAggregate("product-1");
+        expect(agg.avgRating).toBe(3.3);
+    });
+    it("no reviews → count=0, avgRating=0", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const agg = await repo.getApprovedRatingAggregate("product-none");
+        expect(agg).toEqual({ count: 0, avgRating: 0 });
+    });
+});
+// ---------------------------------------------------------------------------
+// findApprovedByProduct
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.findApprovedByProduct", () => {
+    it("queries by productId AND status=approved", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findApprovedByProduct("product-1");
+        expect(mockCollection.where).toHaveBeenCalledWith("productId", "==", "product-1");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "approved");
+    });
+    it("orders results by createdAt descending", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findApprovedByProduct("product-1");
+        expect(mockQuery.orderBy).toHaveBeenCalledWith("createdAt", "desc");
+    });
+    it("does NOT return pending reviews", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const results = await repo.findApprovedByProduct("product-1");
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// findPending
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.findPending", () => {
+    it("queries by status=pending", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findPending();
+        expect(mockCollection.where).toHaveBeenCalledWith("status", "==", "pending");
+    });
+    it("returns only pending reviews", async () => {
+        const pending = makeReviewDoc({ status: "pending" });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: pending.id, data: pending }]));
+        const results = await repo.findPending();
+        expect(results).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// findFeatured
+// ---------------------------------------------------------------------------
+describe("ReviewRepository.findFeatured", () => {
+    it("queries by featured=true AND status=approved", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findFeatured();
+        expect(mockCollection.where).toHaveBeenCalledWith("featured", "==", true);
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "approved");
+    });
+    it("applies default limit of 18", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findFeatured();
+        expect(mockQuery.limit).toHaveBeenCalledWith(18);
+    });
+    it("applies custom limit when provided", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.findFeatured(6);
+        expect(mockQuery.limit).toHaveBeenCalledWith(6);
+    });
+});

package/dist/features/reviews/schemas/firestore.d.ts

@@ -2,6 +2,7 @@
  * Reviews Firestore Document Types & Constants
  */
 import type { ReviewStatus } from "../types";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 /** Runtime-accessible review status values — use instead of bare string literals. */
 export declare const ReviewStatusValues: {
     readonly PENDING: "pending";
@@ -15,8 +16,7 @@ export interface ReviewVideoField {
     trimStart?: number;
     trimEnd?: number;
 }
-export interface ReviewDocument {
-    id: string;
+export interface ReviewDocument extends BaseDocument {
     productId: string;
     productTitle: string;
     storeId?: string;
@@ -44,8 +44,6 @@ export interface ReviewDocument {
     isAnonymous?: boolean;
     sellerReply?: string;
     sellerRepliedAt?: Date;
-    createdAt: Date;
-    updatedAt: Date;
     approvedAt?: Date;
     rejectedAt?: Date;
 }

package/dist/features/reviews/schemas/index.d.ts

@@ -103,8 +103,8 @@ export declare const reviewFirestoreSchema: z.ZodObject<{
     createdAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    id: string;
     title: string;
+    id: string;
     updatedAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
@@ -150,8 +150,8 @@ export declare const reviewFirestoreSchema: z.ZodObject<{
     createdAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    id: string;
     title: string;
+    id: string;
     updatedAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;

package/dist/features/scams/repository/__tests__/scammer.repository.test.d.ts

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