@mohasinac/appkit 3.0.6 → 3.1.1

package/dist/features/lottery/schemas/zod.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Zod schemas for lottery entry submission and validation.
+ */
+import { z } from "zod";
+export declare const lotteryEntrySubmitSchema: z.ZodObject<{
+    transactionId: z.ZodString;
+    paymentTime: z.ZodString;
+    purchasedItemNumber: z.ZodNumber;
+    userPhone: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    transactionId: string;
+    userPhone: string;
+    paymentTime: string;
+    purchasedItemNumber: number;
+}, {
+    transactionId: string;
+    userPhone: string;
+    paymentTime: string;
+    purchasedItemNumber: number;
+}>;
+export type LotteryEntrySubmitInput = z.infer<typeof lotteryEntrySubmitSchema>;
+/** Schema for flag action */
+export declare const flagLotteryEntrySchema: z.ZodObject<{
+    entryId: z.ZodString;
+    flagNote: z.ZodString;
+    flaggedByUserId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    flagNote: string;
+    entryId: string;
+    flaggedByUserId: string;
+}, {
+    flagNote: string;
+    entryId: string;
+    flaggedByUserId: string;
+}>;
+export type FlagLotteryEntryInput = z.infer<typeof flagLotteryEntrySchema>;
+/** Schema for reopen-slot action */
+export declare const reopenLotterySlotSchema: z.ZodObject<{
+    sourceType: z.ZodEnum<["event", "product"]>;
+    sourceId: z.ZodString;
+    slotNumber: z.ZodNumber;
+    adminUserId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    slotNumber: number;
+    sourceType: "product" | "event";
+    sourceId: string;
+    adminUserId: string;
+}, {
+    slotNumber: number;
+    sourceType: "product" | "event";
+    sourceId: string;
+    adminUserId: string;
+}>;
+export type ReopenLotterySlotInput = z.infer<typeof reopenLotterySlotSchema>;
+/** Schema for submit lottery pull (full, server-side) */
+export declare const submitLotteryPullSchema: z.ZodEffects<z.ZodObject<{
+    sourceType: z.ZodEnum<["event", "product"]>;
+    eventId: z.ZodOptional<z.ZodString>;
+    productId: z.ZodOptional<z.ZodString>;
+    userId: z.ZodString;
+    userDisplayName: z.ZodOptional<z.ZodString>;
+    userEmail: z.ZodOptional<z.ZodString>;
+} & {
+    transactionId: z.ZodString;
+    paymentTime: z.ZodString;
+    purchasedItemNumber: z.ZodNumber;
+    userPhone: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    userId: string;
+    transactionId: string;
+    userPhone: string;
+    sourceType: "product" | "event";
+    paymentTime: string;
+    purchasedItemNumber: number;
+    productId?: string | undefined;
+    userEmail?: string | undefined;
+    userDisplayName?: string | undefined;
+    eventId?: string | undefined;
+}, {
+    userId: string;
+    transactionId: string;
+    userPhone: string;
+    sourceType: "product" | "event";
+    paymentTime: string;
+    purchasedItemNumber: number;
+    productId?: string | undefined;
+    userEmail?: string | undefined;
+    userDisplayName?: string | undefined;
+    eventId?: string | undefined;
+}>, {
+    userId: string;
+    transactionId: string;
+    userPhone: string;
+    sourceType: "product" | "event";
+    paymentTime: string;
+    purchasedItemNumber: number;
+    productId?: string | undefined;
+    userEmail?: string | undefined;
+    userDisplayName?: string | undefined;
+    eventId?: string | undefined;
+}, {
+    userId: string;
+    transactionId: string;
+    userPhone: string;
+    sourceType: "product" | "event";
+    paymentTime: string;
+    purchasedItemNumber: number;
+    productId?: string | undefined;
+    userEmail?: string | undefined;
+    userDisplayName?: string | undefined;
+    eventId?: string | undefined;
+}>;
+export type SubmitLotteryPullInput = z.infer<typeof submitLotteryPullSchema>;

package/dist/features/lottery/schemas/zod.js

@@ -0,0 +1,39 @@
+/**
+ * Zod schemas for lottery entry submission and validation.
+ */
+import { z } from "zod";
+export const lotteryEntrySubmitSchema = z.object({
+    transactionId: z.string().min(4, "Transaction ID must be at least 4 characters"),
+    paymentTime: z.string().datetime({ message: "Payment time must be a valid ISO datetime" }),
+    purchasedItemNumber: z.number().int().min(1, "Item number must be at least 1"),
+    userPhone: z
+        .string()
+        .min(10, "Phone number must be at least 10 digits")
+        .regex(/^\+?[\d\s\-()]{10,}$/, "Enter a valid phone number"),
+});
+/** Schema for flag action */
+export const flagLotteryEntrySchema = z.object({
+    entryId: z.string().min(1),
+    flagNote: z.string().min(1, "Flag note is required"),
+    flaggedByUserId: z.string().min(1),
+});
+/** Schema for reopen-slot action */
+export const reopenLotterySlotSchema = z.object({
+    sourceType: z.enum(["event", "product"]),
+    sourceId: z.string().min(1),
+    slotNumber: z.number().int().min(1),
+    adminUserId: z.string().min(1),
+});
+/** Schema for submit lottery pull (full, server-side) */
+export const submitLotteryPullSchema = z
+    .object({
+    sourceType: z.enum(["event", "product"]),
+    eventId: z.string().optional(),
+    productId: z.string().optional(),
+    userId: z.string().min(1),
+    userDisplayName: z.string().optional(),
+    userEmail: z.string().email().optional(),
+})
+    .merge(lotteryEntrySubmitSchema)
+    .refine((data) => (data.sourceType === "event" && !!data.eventId) ||
+    (data.sourceType === "product" && !!data.productId), { message: "eventId or productId must be provided matching sourceType" });

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

@@ -0,0 +1,67 @@
+/**
+ * Lottery feature shared types
+ *
+ * Used by both event-type lottery and prize-draw-mode lottery.
+ * Weight + price fields are server-only — never sent to client consumers.
+ */
+export interface LotterySlot {
+    slotNumber: number;
+    name: string;
+    priceInPaise: number;
+    weight: number;
+    isBooked: boolean;
+    bookedByUserLotteryNumber?: number;
+    bookedByUserId?: string;
+    bookedByDisplayName?: string;
+}
+/** Slot shape safe to expose to clients — price and weight stripped by adapter. */
+export interface ClientLotterySlot {
+    slotNumber: number;
+    name: string;
+    isBooked: boolean;
+    bookedByUserLotteryNumber?: number;
+    bookedByDisplayName?: string;
+}
+export type LotteryPricingMode = "uniform" | "variable";
+export interface LotteryConfig {
+    slots: LotterySlot[];
+    totalSlots: number;
+    pricingMode: LotteryPricingMode;
+    uniformPriceInPaise?: number;
+    drawWindowDurationMinutes: number;
+    maxPullsPerTransaction: number;
+    maxPullsPerUser: number;
+}
+/** Client-safe config shape — slots have price/weight stripped. */
+export interface ClientLotteryConfig {
+    slots: ClientLotterySlot[];
+    totalSlots: number;
+    pricingMode: LotteryPricingMode;
+    drawWindowDurationMinutes: number;
+    maxPullsPerTransaction: number;
+    maxPullsPerUser: number;
+}
+export type LotteryEntryStatus = "pending" | "drawn" | "won" | "flagged" | "cancelled";
+/** Error codes thrown by lottery actions */
+export type LotteryErrorCode = "LOTTERY_FULL" | "LOTTERY_WINDOW_CLOSED" | "USER_LIMIT_REACHED" | "TX_ALREADY_USED" | "SLOT_NOT_FOUND" | "ENTRY_NOT_FLAGGED";
+export declare class LotteryError extends Error {
+    readonly code: LotteryErrorCode;
+    constructor(code: LotteryErrorCode, message: string);
+}
+/**
+ * Compute the weight for a slot given its price.
+ * Lower price → higher weight → more likely to be selected.
+ * Weight is always at least 1 (never 0).
+ * For uniform pricing: all slots get weight 50.
+ */
+export declare function computeWeight(priceInPaise: number, maxPriceInPaise: number): number;
+/**
+ * Pick a slot using weighted random selection.
+ * @throws {LotteryError} LOTTERY_FULL when unclaimed is empty.
+ */
+export declare function pickWeightedSlot(unclaimed: LotterySlot[]): LotterySlot;
+/**
+ * Assign weights to slots based on pricing mode.
+ * Returns a new array with weight populated on every slot.
+ */
+export declare function assignSlotWeights(config: LotteryConfig): LotterySlot[];

package/dist/features/lottery/types/index.js

@@ -0,0 +1,55 @@
+/**
+ * Lottery feature shared types
+ *
+ * Used by both event-type lottery and prize-draw-mode lottery.
+ * Weight + price fields are server-only — never sent to client consumers.
+ */
+export class LotteryError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "LotteryError";
+    }
+}
+/**
+ * Compute the weight for a slot given its price.
+ * Lower price → higher weight → more likely to be selected.
+ * Weight is always at least 1 (never 0).
+ * For uniform pricing: all slots get weight 50.
+ */
+export function computeWeight(priceInPaise, maxPriceInPaise) {
+    if (maxPriceInPaise === 0)
+        return 50;
+    return Math.max(1, Math.round((1 - priceInPaise / maxPriceInPaise) * 99) + 1);
+}
+/**
+ * Pick a slot using weighted random selection.
+ * @throws {LotteryError} LOTTERY_FULL when unclaimed is empty.
+ */
+export function pickWeightedSlot(unclaimed) {
+    if (unclaimed.length === 0) {
+        throw new LotteryError("LOTTERY_FULL", "No unclaimed slots remain.");
+    }
+    const total = unclaimed.reduce((s, sl) => s + sl.weight, 0);
+    let r = Math.random() * total;
+    for (const sl of unclaimed) {
+        r -= sl.weight;
+        if (r <= 0)
+            return sl;
+    }
+    return unclaimed[unclaimed.length - 1];
+}
+/**
+ * Assign weights to slots based on pricing mode.
+ * Returns a new array with weight populated on every slot.
+ */
+export function assignSlotWeights(config) {
+    if (config.pricingMode === "uniform") {
+        return config.slots.map((sl) => ({ ...sl, weight: 50 }));
+    }
+    const maxPrice = Math.max(...config.slots.map((sl) => sl.priceInPaise), 0);
+    return config.slots.map((sl) => ({
+        ...sl,
+        weight: computeWeight(sl.priceInPaise, maxPrice),
+    }));
+}

package/dist/features/messages/repository/__tests__/conversations.repository.test.d.ts

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

package/dist/features/messages/repository/__tests__/conversations.repository.test.js

@@ -0,0 +1,257 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockTxn } = makeMockDb();
+vi.mock("../../../../providers/db-firebase", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { ConversationsRepository } from "../conversations.repository";
+const repo = new ConversationsRepository();
+function makeConvData(overrides = {}) {
+    return {
+        buyerId: "user-ravi",
+        buyerDisplayName: "Ravi Kumar",
+        storeId: "store-pokemon-palace",
+        storeName: "Pokemon Palace",
+        sellerDisplayName: "Misty Singh",
+        productId: "product-charizard",
+        productTitle: "Charizard PSA9",
+        messages: [],
+        lastMessage: "",
+        lastMessageAt: new Date(),
+        unreadBuyer: 0,
+        unreadSeller: 0,
+        status: "active",
+        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.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+    mockDocRef.get.mockResolvedValue({ exists: false, id: "mock-id", data: () => ({}) });
+    mockDocRef.update.mockResolvedValue(undefined);
+    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
+    mockTxn.get.mockResolvedValue({ exists: false, id: "mock-id", data: () => ({}) });
+    mockTxn.set.mockReturnValue(undefined);
+    mockTxn.update.mockReturnValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// findOrCreateByContext
+// ---------------------------------------------------------------------------
+describe("ConversationsRepository.findOrCreateByContext", () => {
+    it("generates stable ID: conv-{buyerId}-{storeId}-{productId}", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-user-ravi-store-pokemon-palace-product-charizard", data: () => convData });
+        const result = await repo.findOrCreateByContext({
+            buyerId: "user-ravi",
+            buyerDisplayName: "Ravi Kumar",
+            storeId: "store-pokemon-palace",
+            storeName: "Pokemon Palace",
+            sellerDisplayName: "Misty Singh",
+            productId: "product-charizard",
+        });
+        expect(mockCollection.doc).toHaveBeenCalledWith("conv-user-ravi-store-pokemon-palace-product-charizard");
+        expect(result.buyerId).toBe("user-ravi");
+    });
+    it("uses 'general' productKey when productId is not provided", async () => {
+        const convData = makeConvData({ productId: undefined });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-user-ravi-store-1-general", data: () => convData });
+        await repo.findOrCreateByContext({
+            buyerId: "user-ravi",
+            buyerDisplayName: "Ravi",
+            storeId: "store-1",
+            storeName: "Store 1",
+            sellerDisplayName: "Seller 1",
+        });
+        expect(mockCollection.doc).toHaveBeenCalledWith("conv-user-ravi-store-1-general");
+    });
+    it("returns existing conversation without creating a new one (idempotent)", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-abc", data: () => convData });
+        await repo.findOrCreateByContext({
+            buyerId: "user-ravi",
+            buyerDisplayName: "Ravi",
+            storeId: "store-1",
+            storeName: "Store 1",
+            sellerDisplayName: "Seller",
+        });
+        expect(mockTxn.set).not.toHaveBeenCalled();
+    });
+    it("creates a new conversation when one does not exist", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-new", data: () => ({}) });
+        await repo.findOrCreateByContext({
+            buyerId: "user-new",
+            buyerDisplayName: "New Buyer",
+            storeId: "store-new",
+            storeName: "New Store",
+            sellerDisplayName: "New Seller",
+        });
+        expect(mockTxn.set).toHaveBeenCalledOnce();
+    });
+    it("new conversation starts with messages=[], unreadBuyer=0, unreadSeller=0", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-new", data: () => ({}) });
+        const result = await repo.findOrCreateByContext({
+            buyerId: "user-new",
+            buyerDisplayName: "New",
+            storeId: "store-new",
+            storeName: "New Store",
+            sellerDisplayName: "Seller",
+        });
+        expect(result.messages).toHaveLength(0);
+        expect(result.unreadBuyer).toBe(0);
+        expect(result.unreadSeller).toBe(0);
+    });
+    it("uses Firestore transaction for atomicity", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-new", data: () => ({}) });
+        await repo.findOrCreateByContext({
+            buyerId: "user-a",
+            buyerDisplayName: "A",
+            storeId: "store-b",
+            storeName: "B",
+            sellerDisplayName: "Seller",
+        });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// appendMessage
+// ---------------------------------------------------------------------------
+describe("ConversationsRepository.appendMessage", () => {
+    it("increments unreadBuyer when seller sends a message", async () => {
+        const convData = makeConvData({ unreadBuyer: 0, unreadSeller: 0 });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "seller-uid",
+            senderRole: "seller",
+            body: "Hello buyer!",
+        });
+        expect(result.unreadBuyer).toBe(1);
+        expect(result.unreadSeller).toBe(0);
+    });
+    it("increments unreadSeller when buyer sends a message", async () => {
+        const convData = makeConvData({ unreadBuyer: 0, unreadSeller: 2 });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "Hello seller!",
+        });
+        expect(result.unreadSeller).toBe(3);
+        expect(result.unreadBuyer).toBe(0);
+    });
+    it("appends the new message to the existing messages array", async () => {
+        const existingMsg = {
+            id: "msg-old",
+            senderId: "seller-uid",
+            senderRole: "seller",
+            body: "Previous message",
+            isRead: false,
+            sentAt: new Date(),
+        };
+        const convData = makeConvData({ messages: [existingMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "New message",
+        });
+        expect(result.messages).toHaveLength(2);
+        expect(result.messages[1].body).toBe("New message");
+    });
+    it("sets isRead: false on the new message", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "Test",
+        });
+        expect(result.messages[0].isRead).toBe(false);
+    });
+    it("updates lastMessage and lastMessageAt", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        const result = await repo.appendMessage("conv-1", {
+            senderId: "buyer-uid",
+            senderRole: "buyer",
+            body: "Latest message",
+        });
+        expect(result.lastMessage).toBe("Latest message");
+        expect(result.lastMessageAt).toBeInstanceOf(Date);
+    });
+    it("uses Firestore transaction", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.appendMessage("conv-1", { senderId: "uid", senderRole: "buyer", body: "msg" });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+        expect(mockTxn.update).toHaveBeenCalledOnce();
+    });
+    it("throws when conversation not found", async () => {
+        mockTxn.get.mockResolvedValue({ exists: false, id: "conv-ghost", data: () => ({}) });
+        await expect(repo.appendMessage("conv-ghost", { senderId: "uid", senderRole: "buyer", body: "msg" })).rejects.toThrow(/not found/i);
+    });
+});
+// ---------------------------------------------------------------------------
+// markRead
+// ---------------------------------------------------------------------------
+describe("ConversationsRepository.markRead", () => {
+    it("zeroes unreadBuyer when role=buyer", async () => {
+        const sellerMsg = { id: "m1", senderId: "seller", senderRole: "seller", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ unreadBuyer: 3, unreadSeller: 1, messages: [sellerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        expect(updateArg.unreadBuyer).toBe(0);
+    });
+    it("does NOT touch unreadSeller when buyer reads", async () => {
+        const convData = makeConvData({ unreadBuyer: 2, unreadSeller: 5 });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        expect(updateArg).not.toHaveProperty("unreadSeller");
+    });
+    it("zeroes unreadSeller when role=seller", async () => {
+        const buyerMsg = { id: "m1", senderId: "buyer", senderRole: "buyer", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ unreadBuyer: 2, unreadSeller: 4, messages: [buyerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "seller");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        expect(updateArg.unreadSeller).toBe(0);
+    });
+    it("marks seller-sent messages as isRead=true when buyer reads", async () => {
+        const sellerMsg = { id: "m1", senderId: "seller", senderRole: "seller", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ messages: [sellerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        const msgs = updateArg.messages;
+        expect(msgs[0].isRead).toBe(true);
+    });
+    it("does NOT mark buyer-sent messages when buyer reads (only marks counterparty)", async () => {
+        const buyerMsg = { id: "m1", senderId: "buyer", senderRole: "buyer", body: "Hi", isRead: false, sentAt: new Date() };
+        const convData = makeConvData({ messages: [buyerMsg] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        const updateArg = mockTxn.update.mock.calls[0][1];
+        const msgs = updateArg.messages;
+        expect(msgs[0].isRead).toBe(false);
+    });
+    it("uses Firestore transaction", async () => {
+        const convData = makeConvData();
+        mockTxn.get.mockResolvedValue({ exists: true, id: "conv-1", data: () => convData });
+        await repo.markRead("conv-1", "buyer");
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+    });
+});

package/dist/features/orders/repository/__tests__/orders.repository.test.d.ts

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