@mohasinac/appkit 3.0.6 → 3.1.0

package/dist/features/events/schemas/index.js

@@ -19,8 +19,11 @@ export const eventTypeSchema = z.enum([
     "poll",
     "survey",
     "feedback",
+    "raffle",
+    "spin_wheel",
+    "lottery",
 ]);
-export const eventStatusSchema = z.enum(["draft", "active", "paused", "ended"]);
+export const eventStatusSchema = z.enum(["draft", "active", "paused", "ended", "cancelled"]);
 export const saleConfigSchema = z.object({
     discountPercent: z.number(),
     bannerText: z.string().optional(),
@@ -36,6 +39,60 @@ export const pollConfigSchema = z.object({
     allowComment: z.boolean(),
     options: z.array(z.object({ id: z.string(), label: z.string() })),
     resultsVisibility: z.enum(["always", "after_vote", "after_end"]),
+    requireLogin: z.boolean().optional(),
+});
+export const surveyFormFieldSchema = z.object({
+    id: z.string(),
+    type: z.enum(["text", "textarea", "email", "phone", "number", "select", "multiselect", "checkbox", "radio", "date", "rating", "file"]),
+    label: z.string(),
+    placeholder: z.string().optional(),
+    required: z.boolean(),
+    options: z.array(z.string()).optional(),
+    validation: z.object({
+        minLength: z.number().optional(),
+        maxLength: z.number().optional(),
+        min: z.number().optional(),
+        max: z.number().optional(),
+        pattern: z.string().optional(),
+    }).optional(),
+    order: z.number(),
+});
+export const surveyConfigSchema = z.object({
+    requireLogin: z.boolean(),
+    maxEntriesPerUser: z.number(),
+    hasLeaderboard: z.boolean(),
+    hasPointSystem: z.boolean(),
+    pointsLabel: z.string().optional(),
+    entryReviewRequired: z.boolean(),
+    formFields: z.array(surveyFormFieldSchema),
+});
+export const feedbackConfigSchema = z.object({
+    formFields: z.array(surveyFormFieldSchema),
+    anonymous: z.boolean(),
+});
+export const spinPrizeSchema = z.object({
+    id: z.string(),
+    label: z.string(),
+    couponId: z.string().optional(),
+    weight: z.number(),
+    isActive: z.boolean(),
+});
+/** Lottery slot schema — client-safe shape (no priceInPaise/weight sent to clients). */
+export const lotterySlotClientSchema = z.object({
+    slotNumber: z.number().int().min(1),
+    name: z.string(),
+    isBooked: z.boolean(),
+    bookedByUserLotteryNumber: z.number().optional(),
+    bookedByDisplayName: z.string().optional(),
+});
+/** Client-safe lottery config schema — price/weight fields stripped server-side. */
+export const lotteryConfigClientSchema = z.object({
+    slots: z.array(lotterySlotClientSchema),
+    totalSlots: z.number().int().min(1).max(200),
+    pricingMode: z.enum(["uniform", "variable"]),
+    drawWindowDurationMinutes: z.number(),
+    maxPullsPerTransaction: z.number().int().min(1),
+    maxPullsPerUser: z.number().int().min(1),
 });
 // --- Base item schema ---------------------------------------------------------
 /**
@@ -53,6 +110,7 @@ export const pollConfigSchema = z.object({
  */
 export const eventItemSchema = z.object({
     id: z.string(),
+    slug: z.string().optional(),
     type: eventTypeSchema,
     title: z.string(),
     description: z.string(),
@@ -67,6 +125,27 @@ export const eventItemSchema = z.object({
     saleConfig: saleConfigSchema.optional(),
     offerConfig: offerConfigSchema.optional(),
     pollConfig: pollConfigSchema.optional(),
+    surveyConfig: surveyConfigSchema.optional(),
+    feedbackConfig: feedbackConfigSchema.optional(),
+    // Raffle fields
+    hasRaffle: z.boolean().optional(),
+    raffleType: z.enum(["top_n_scorers", "top_n_participants", "open_raffle", "spin_wheel"]).optional(),
+    raffleTopN: z.number().optional(),
+    rafflePrize: z.string().optional(),
+    rafflePrizeCouponId: z.string().optional(),
+    rafflePrizeProductIds: z.array(z.string()).optional(),
+    raffleGithubFunctionUrl: z.string().optional(),
+    raffleWinnerUserId: z.string().optional(),
+    raffleWinnerDisplayName: z.string().optional(),
+    raffleTriggeredAt: z.string().optional(),
+    raffleEntryCount: z.number().optional(),
+    // Spin wheel fields
+    spinPrizes: z.array(spinPrizeSchema).optional(),
+    spinMaxPerUser: z.number().optional(),
+    spinWindowStart: z.string().optional(),
+    spinWindowEnd: z.string().optional(),
+    // Lottery config (new) — client-safe shape (price/weight stripped by adapter)
+    lotteryConfig: lotteryConfigClientSchema.optional(),
     stats: z.object({
         totalEntries: z.number(),
         approvedEntries: z.number(),

package/dist/features/events/types/index.d.ts

@@ -1,6 +1,7 @@
 import type { MediaField } from "../../media/types/index";
 import type { JsonValue } from "@mohasinac/appkit";
-export type EventType = "sale" | "offer" | "poll" | "survey" | "feedback" | "raffle" | "spin_wheel";
+import type { ClientLotteryConfig } from "../../lottery/types";
+export type EventType = "sale" | "offer" | "poll" | "survey" | "feedback" | "raffle" | "spin_wheel" | "lottery";
 export type RaffleType = "top_n_scorers" | "top_n_participants" | "open_raffle" | "spin_wheel";
 export interface SpinPrize {
     id: string;
@@ -96,6 +97,8 @@ export interface EventItem {
     spinMaxPerUser?: number;
     spinWindowStart?: string;
     spinWindowEnd?: string;
+    /** Lottery config — slots have price/weight stripped for client consumption. */
+    lotteryConfig?: ClientLotteryConfig;
     stats: {
         totalEntries: number;
         approvedEntries: number;

package/dist/features/faq/repository/__tests__/faqs.repository.test.d.ts

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

package/dist/features/faq/repository/__tests__/faqs.repository.test.js

@@ -0,0 +1,311 @@
+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("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { FirebaseFAQsRepository } from "../faqs.repository";
+const repo = new FirebaseFAQsRepository();
+function makeFaqDoc(overrides = {}) {
+    return {
+        id: "faq-how-does-bidding-work",
+        question: "How does bidding work?",
+        answer: { text: "You place a bid above the current price.", format: "plain" },
+        category: "Auctions",
+        tags: ["bidding", "auctions"],
+        searchTokens: ["how", "does", "bidding", "work"],
+        relatedFAQs: [],
+        seo: { slug: "how-does-bidding-work" },
+        isActive: true,
+        showOnHomepage: false,
+        showInFooter: false,
+        isPinned: false,
+        priority: 0,
+        order: 0,
+        useSiteSettings: false,
+        createdBy: "admin-1",
+        stats: { views: 0, helpful: 0, notHelpful: 0 },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        ...overrides,
+    };
+}
+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);
+});
+// ---------------------------------------------------------------------------
+// createWithSlug
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.createWithSlug", () => {
+    it("uses seo.slug from input when provided", async () => {
+        const input = {
+            question: "How does bidding work?",
+            answer: { text: "You bid above the current price.", format: "plain" },
+            category: "Auctions",
+            tags: ["bidding"],
+            seo: { slug: "custom-slug" },
+            isActive: true,
+        };
+        const result = await repo.createWithSlug(input);
+        expect(result.seo.slug).toBe("custom-slug");
+    });
+    it("generates seo.slug from question when seo.slug not provided", async () => {
+        const input = {
+            question: "How does bidding work?",
+            answer: { text: "Details here.", format: "plain" },
+            category: "Auctions",
+            tags: [],
+            isActive: true,
+        };
+        const result = await repo.createWithSlug(input);
+        expect(result.seo.slug).toMatch(/bidding/i);
+    });
+    it("builds searchTokens from question, answer, category, and tags", async () => {
+        const input = {
+            question: "What is a reserve price?",
+            answer: { text: "Reserve is the minimum.", format: "plain" },
+            category: "Auctions",
+            tags: ["reserve", "price"],
+            seo: { slug: "what-is-reserve-price" },
+            isActive: true,
+        };
+        const result = await repo.createWithSlug(input);
+        expect(result.searchTokens).toContain("reserve");
+        expect(result.searchTokens).toContain("price");
+        expect(result.searchTokens).toContain("what");
+    });
+    it("sets stats.views=0, stats.helpful=0, stats.notHelpful=0", async () => {
+        const input = {
+            question: "New question?",
+            answer: { text: "Answer.", format: "plain" },
+            category: "General",
+            tags: [],
+            isActive: true,
+        };
+        const result = await repo.createWithSlug(input);
+        expect(result.stats).toEqual({ views: 0, helpful: 0, notHelpful: 0 });
+    });
+    it("persists the FAQ to Firestore", async () => {
+        const input = {
+            question: "Question?",
+            answer: { text: "Answer.", format: "plain" },
+            category: "General",
+            tags: [],
+            seo: { slug: "question" },
+            isActive: true,
+        };
+        await repo.createWithSlug(input);
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("searchTokens deduplicated and lowercased", async () => {
+        const input = {
+            question: "What what what?",
+            answer: { text: "Answer.", format: "plain" },
+            category: "General",
+            tags: [],
+            isActive: true,
+        };
+        const result = await repo.createWithSlug(input);
+        const whatCount = result.searchTokens.filter((t) => t === "what").length;
+        expect(whatCount).toBe(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// interpolateVariables
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.interpolateVariables", () => {
+    it("replaces {{variable}} placeholders with provided values", async () => {
+        const faq = makeFaqDoc({
+            answer: { text: "Your order {{orderId}} will arrive in {{days}} days.", format: "plain" },
+        });
+        const result = await repo.interpolateVariables(faq, { orderId: "ORD-123", days: 3 });
+        expect(result.answer.interpolated).toBe("Your order ORD-123 will arrive in 3 days.");
+    });
+    it("falls back to faq.variables when runtime variable not provided", async () => {
+        const faq = makeFaqDoc({
+            answer: { text: "Contact us at {{supportEmail}}.", format: "plain" },
+            variables: { supportEmail: "support@letitrip.in" },
+        });
+        const result = await repo.interpolateVariables(faq);
+        expect(result.answer.interpolated).toBe("Contact us at support@letitrip.in.");
+    });
+    it("leaves unknown placeholders as-is", async () => {
+        const faq = makeFaqDoc({
+            answer: { text: "Hello {{unknownVar}}!", format: "plain" },
+        });
+        const result = await repo.interpolateVariables(faq, {});
+        expect(result.answer.interpolated).toBe("Hello {{unknownVar}}!");
+    });
+    it("returns unchanged interpolated when no placeholders present", async () => {
+        const faq = makeFaqDoc({
+            answer: { text: "No variables here.", format: "plain" },
+        });
+        const result = await repo.interpolateVariables(faq, { irrelevant: "x" });
+        expect(result.answer.interpolated).toBe("No variables here.");
+    });
+    it("replaces multiple occurrences of the same placeholder", async () => {
+        const faq = makeFaqDoc({
+            answer: { text: "{{name}} is {{name}}.", format: "plain" },
+        });
+        const result = await repo.interpolateVariables(faq, { name: "LetItRip" });
+        expect(result.answer.interpolated).toBe("LetItRip is LetItRip.");
+    });
+});
+// ---------------------------------------------------------------------------
+// markHelpful
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.markHelpful", () => {
+    it("increments stats.helpful on the FAQ document", async () => {
+        await repo.markHelpful("faq-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.helpful": expect.anything() }));
+    });
+    it("does not modify other stats fields", async () => {
+        await repo.markHelpful("faq-1");
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(Object.keys(updateArg)).not.toContain("stats.views");
+        expect(Object.keys(updateArg)).not.toContain("stats.notHelpful");
+    });
+});
+// ---------------------------------------------------------------------------
+// markNotHelpful
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.markNotHelpful", () => {
+    it("increments stats.notHelpful on the FAQ document", async () => {
+        await repo.markNotHelpful("faq-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.notHelpful": expect.anything() }));
+    });
+    it("does not modify stats.helpful", async () => {
+        await repo.markNotHelpful("faq-1");
+        const updateArg = mockDocRef.update.mock.calls[0][0];
+        expect(Object.keys(updateArg)).not.toContain("stats.helpful");
+    });
+});
+// ---------------------------------------------------------------------------
+// incrementViews
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.incrementViews", () => {
+    it("increments stats.views by 1", async () => {
+        await repo.incrementViews("faq-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.views": expect.anything() }));
+    });
+    it("sets stats.lastViewed timestamp", async () => {
+        await repo.incrementViews("faq-1");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ "stats.lastViewed": expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// getHomepageFAQs
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.getHomepageFAQs", () => {
+    it("queries showOnHomepage=true AND isActive=true", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getHomepageFAQs();
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("showOnHomepage"), "==", true);
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
+    });
+    it("orders results by priority descending", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getHomepageFAQs();
+        expect(mockQuery.orderBy).toHaveBeenCalledWith(expect.stringContaining("priority"), "desc");
+    });
+    it("returns matching FAQs", async () => {
+        const faq = makeFaqDoc({ showOnHomepage: true });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: faq.id, data: faq }]));
+        const results = await repo.getHomepageFAQs();
+        expect(results).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// searchByTag
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.searchByTag", () => {
+    it("filters by array-contains on the tags field", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.searchByTag("grading");
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("tags"), "array-contains", "grading");
+    });
+    it("also filters isActive=true", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.searchByTag("returns");
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
+    });
+    it("returns matching FAQs", async () => {
+        const faq = makeFaqDoc({ tags: ["grading"] });
+        mockQuery.get.mockResolvedValue(makeQuerySnap([{ id: faq.id, data: faq }]));
+        const results = await repo.searchByTag("grading");
+        expect(results).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// getPinnedFAQs
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.getPinnedFAQs", () => {
+    it("queries isPinned=true AND isActive=true", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getPinnedFAQs();
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("isPinned"), "==", true);
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
+    });
+    it("orders by order field ascending", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getPinnedFAQs();
+        expect(mockQuery.orderBy).toHaveBeenCalledWith(expect.stringContaining("order"), "asc");
+    });
+    it("filters by category when provided", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getPinnedFAQs("Shipping");
+        expect(mockQuery.where).toHaveBeenCalledWith(expect.stringContaining("category"), "==", "Shipping");
+    });
+    it("no category filter applied when category not provided", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getPinnedFAQs();
+        const whereCalls = mockQuery.where.mock.calls;
+        const categoryFilter = whereCalls.find((c) => c[0].includes("category"));
+        expect(categoryFilter).toBeUndefined();
+    });
+});
+// ---------------------------------------------------------------------------
+// getMostHelpful
+// ---------------------------------------------------------------------------
+describe("FirebaseFAQsRepository.getMostHelpful", () => {
+    it("filters by isActive=true", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getMostHelpful();
+        expect(mockCollection.where).toHaveBeenCalledWith(expect.stringContaining("isActive"), "==", true);
+    });
+    it("orders by stats.helpful descending", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getMostHelpful();
+        expect(mockQuery.orderBy).toHaveBeenCalledWith("stats.helpful", "desc");
+    });
+    it("applies default limit of 10", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getMostHelpful();
+        expect(mockQuery.limit).toHaveBeenCalledWith(10);
+    });
+    it("applies custom limit when provided", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getMostHelpful(5);
+        expect(mockQuery.limit).toHaveBeenCalledWith(5);
+    });
+});

package/dist/features/history/repository/__tests__/user-history.repository.test.d.ts

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

package/dist/features/history/repository/__tests__/user-history.repository.test.js

@@ -0,0 +1,180 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockTxn } = makeMockDb();
+vi.mock("../../../../providers/db-firebase", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+import { UserHistoryRepository } from "../user-history.repository";
+import { HISTORY_MAX } from "../../../../constants/limits";
+const repo = new UserHistoryRepository();
+function makeHistoryItems(count, baseDate = new Date("2026-01-01")) {
+    return Array.from({ length: count }, (_, i) => ({
+        productId: `product-${i}`,
+        productType: "product",
+        viewedAt: new Date(baseDate.getTime() - i * 1000),
+    }));
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockTxn.get.mockResolvedValue(makeSnap(null));
+    mockTxn.set.mockReturnValue(undefined);
+});
+describe("UserHistoryRepository.track", () => {
+    it("empty history → items has 1 entry, returns 1", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        const count = await repo.track("u", { productId: "product-x", productType: "product" });
+        expect(count).toBe(1);
+        expect(mockTxn.set).toHaveBeenCalledOnce();
+    });
+    it("49 items + new productId → 50 items, new at position 0", async () => {
+        const items = makeHistoryItems(49);
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        const count = await repo.track("u", { productId: "product-new", productType: "product" });
+        expect(count).toBe(50);
+        const setCall = mockTxn.set.mock.calls[0][1];
+        expect(setCall.items[0].productId).toBe("product-new");
+    });
+    it("50 items + new productId → evicts last item, stays at 50 (FIFO)", async () => {
+        const items = makeHistoryItems(HISTORY_MAX);
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        const count = await repo.track("u", { productId: "product-new", productType: "product" });
+        expect(count).toBe(HISTORY_MAX);
+        const setCall = mockTxn.set.mock.calls[0][1];
+        expect(setCall.items).toHaveLength(HISTORY_MAX);
+        expect(setCall.items[0].productId).toBe("product-new");
+        // Last item from original list is evicted
+        expect(setCall.items[HISTORY_MAX - 1].productId).not.toBe(`product-${HISTORY_MAX - 1}`);
+    });
+    it("revisit existing productId → removes old, inserts at position 0, length unchanged", async () => {
+        const items = [
+            { productId: "product-A", productType: "product", viewedAt: new Date("2026-01-03") },
+            { productId: "product-B", productType: "product", viewedAt: new Date("2026-01-02") },
+            { productId: "product-C", productType: "product", viewedAt: new Date("2026-01-01") },
+        ];
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        const count = await repo.track("u", { productId: "product-C", productType: "product" });
+        expect(count).toBe(3);
+        const setCall = mockTxn.set.mock.calls[0][1];
+        expect(setCall.items[0].productId).toBe("product-C");
+        expect(setCall.items.filter((i) => i.productId === "product-C")).toHaveLength(1);
+    });
+    it("uses db.runTransaction", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        await repo.track("u", { productId: "product-x", productType: "product" });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+    });
+    it("stores viewedAt as current timestamp when not provided", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        const before = Date.now();
+        await repo.track("u", { productId: "product-x", productType: "product" });
+        const after = Date.now();
+        const setCall = mockTxn.set.mock.calls[0][1];
+        const ts = setCall.items[0].viewedAt.getTime();
+        expect(ts).toBeGreaterThanOrEqual(before);
+        expect(ts).toBeLessThanOrEqual(after);
+    });
+});
+describe("UserHistoryRepository.merge", () => {
+    it("guest items merged into empty history → all items present", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        const incoming = [
+            { productId: "product-A", productType: "product" },
+            { productId: "product-B", productType: "product" },
+        ];
+        const count = await repo.merge("u", incoming);
+        expect(count).toBe(2);
+    });
+    it("duplicate productId: keeps newer viewedAt, discards older", async () => {
+        const older = new Date("2026-01-01");
+        const newer = new Date("2026-01-10");
+        const existingItems = [{ productId: "product-A", productType: "product", viewedAt: older }];
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: existingItems, updatedAt: new Date() }));
+        await repo.merge("u", [{ productId: "product-A", productType: "product", viewedAt: newer }]);
+        const setCall = mockTxn.set.mock.calls[0][1];
+        expect(setCall.items).toHaveLength(1);
+        expect(setCall.items[0].viewedAt.getTime()).toBe(newer.getTime());
+    });
+    it("result trimmed to HISTORY_MAX (50 items)", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        const incoming = Array.from({ length: 60 }, (_, i) => ({
+            productId: `product-${i}`,
+            productType: "product",
+            viewedAt: new Date(Date.now() - i * 1000),
+        }));
+        const count = await repo.merge("u", incoming);
+        expect(count).toBe(HISTORY_MAX);
+    });
+    it("items sorted descending by viewedAt after merge", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        const incoming = [
+            { productId: "product-old", productType: "product", viewedAt: new Date("2026-01-01") },
+            { productId: "product-new", productType: "product", viewedAt: new Date("2026-01-10") },
+        ];
+        await repo.merge("u", incoming);
+        const setCall = mockTxn.set.mock.calls[0][1];
+        expect(setCall.items[0].productId).toBe("product-new");
+        expect(setCall.items[1].productId).toBe("product-old");
+    });
+    it("uses db.runTransaction", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items: [], updatedAt: new Date() }));
+        await repo.merge("u", []);
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+    });
+});
+describe("UserHistoryRepository.removeOne", () => {
+    it("removes specified productId from items", async () => {
+        const items = [
+            { productId: "product-A", productType: "product", viewedAt: new Date() },
+            { productId: "product-B", productType: "product", viewedAt: new Date() },
+        ];
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        await repo.removeOne("u", "product-A");
+        const setCall = mockTxn.set.mock.calls[0][1];
+        expect(setCall.items).toHaveLength(1);
+        expect(setCall.items[0].productId).toBe("product-B");
+    });
+    it("non-existent productId → no-op, set not called", async () => {
+        const items = [{ productId: "product-A", productType: "product", viewedAt: new Date() }];
+        mockTxn.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        await repo.removeOne("u", "product-xxx");
+        expect(mockTxn.set).not.toHaveBeenCalled();
+    });
+});
+describe("UserHistoryRepository.clearForUser", () => {
+    it("sets items: [] without deleting the document", async () => {
+        await repo.clearForUser("u");
+        expect(mockDocRef.set).toHaveBeenCalledWith(expect.objectContaining({ items: [] }));
+    });
+});
+describe("UserHistoryRepository.getHistory", () => {
+    it("returns items array", async () => {
+        const items = [{ productId: "product-A", productType: "product", viewedAt: new Date() }];
+        mockDocRef.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        const result = await repo.getHistory("u");
+        expect(result).toHaveLength(1);
+        expect(result[0].productId).toBe("product-A");
+    });
+    it("returns empty array for user with no history document", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const result = await repo.getHistory("u");
+        expect(result).toEqual([]);
+    });
+});
+describe("UserHistoryRepository.countByUser", () => {
+    it("returns items.length", async () => {
+        const items = makeHistoryItems(5);
+        mockDocRef.get.mockResolvedValue(makeSnap({ userId: "u", items, updatedAt: new Date() }));
+        const count = await repo.countByUser("u");
+        expect(count).toBe(5);
+    });
+    it("returns 0 for missing document", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const count = await repo.countByUser("u");
+        expect(count).toBe(0);
+    });
+});

package/dist/features/homepage/api/[id]/route.d.ts

@@ -15,9 +15,9 @@ export declare function GET(_request: Request, context: {
     }>;
 }): Promise<NextResponse>;
 export { GET as homepageSectionItemGET };
-export declare const homepageSectionItemPATCH: (request: Request, context: {
+export declare const homepageSectionItemPATCH: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
-export declare const homepageSectionItemDELETE: (request: Request, context: {
+} | undefined) => Promise<Response>;
+export declare const homepageSectionItemDELETE: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/homepage/api/carousel/[id]/route.d.ts

@@ -15,9 +15,9 @@ export declare function GET(_request: Request, context: {
     }>;
 }): Promise<NextResponse>;
 export { GET as carouselItemGET };
-export declare const carouselItemPATCH: (request: Request, context: {
+export declare const carouselItemPATCH: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
-export declare const carouselItemDELETE: (request: Request, context: {
+} | undefined) => Promise<Response>;
+export declare const carouselItemDELETE: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/homepage/api/carousel/route.d.ts

@@ -10,6 +10,6 @@
 import { NextResponse } from "next/server.js";
 export declare function GET(request: Request): Promise<NextResponse>;
 export { GET as carouselGET };
-export declare const carouselPOST: (request: Request, context: {
+export declare const carouselPOST: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;