@mohasinac/appkit 3.0.4 → 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/faq/schemas/firestore.d.ts

@@ -3,13 +3,13 @@
  */
 import type { FAQCategory, FAQAnswer, FAQStats } from "../types";
 export type { FAQCategory, FAQAnswer, FAQStats } from "../types";
+import type { BaseDocument } from "../../../_internal/shared/types/base-document";
 export interface FAQSEO {
     slug: string;
     metaTitle?: string;
     metaDescription?: string;
 }
-export interface FAQDocument {
-    id: string;
+export interface FAQDocument extends BaseDocument {
     question: string;
     answer: FAQAnswer;
     category: FAQCategory;
@@ -29,8 +29,6 @@ export interface FAQDocument {
     seo: FAQSEO;
     isActive: boolean;
     createdBy: string;
-    createdAt: Date;
-    updatedAt: Date;
 }
 export declare const FAQS_COLLECTION: "faqs";
 export declare const FAQS_INDEXED_FIELDS: readonly ["slug", "seo.slug", "category", "order", "showOnHomepage", "showInFooter", "isPinned", "priority", "tags", "searchTokens", "isActive", "stats.helpful", "createdBy", "createdAt"];

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

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

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

@@ -37,9 +37,9 @@ export declare const groupedListingFirestoreSchema: z.ZodObject<{
     createdAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    id: string;
     title: string;
     slug: string;
+    id: string;
     updatedAt: string | Date | z.objectOutputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
@@ -60,9 +60,9 @@ export declare const groupedListingFirestoreSchema: z.ZodObject<{
     createdAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;
-    id: string;
     title: string;
     slug: string;
+    id: string;
     updatedAt: string | Date | z.objectInputType<{
         toDate: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodDate>;
     }, z.ZodTypeAny, "passthrough">;

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

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