@mohasinac/appkit 3.0.4 → 3.1.0

package/dist/_internal/server/features/prize-draws/data.d.ts

@@ -1,17 +1 @@
-/**
- * Prize Draw data layer — OG-coverage-followup 2026-05-23.
- *
- * Prize draws live as products with `listingType:"prize-draw"`. This file
- * wraps the repo call in `React.cache` so the OG renderer and any future
- * page/generateMetadata pair share one Firestore read per request.
- */
-import type { ProductDocument } from "../../../../features/products/schemas/firestore";
-export interface PrizeDrawDataOptions {
-    _reserved?: never;
-}
-/**
- * Fetch a single prize-draw product by slug or id. Returns null when the
- * slug is empty or no matching product exists. The caller is responsible
- * for asserting `listingType === "prize-draw"` if a strict gate is required.
- */
-export declare const getPrizeDrawForDetail: (slugOrId: string, _opts?: PrizeDrawDataOptions) => Promise<ProductDocument | null>;
+export declare const getPrizeDrawForDetail: (slugOrId: string) => Promise<import("../../../..").ProductDocument | null>;

package/dist/_internal/server/features/prize-draws/data.js

@@ -1,20 +1,2 @@
-/**
- * Prize Draw data layer — OG-coverage-followup 2026-05-23.
- *
- * Prize draws live as products with `listingType:"prize-draw"`. This file
- * wraps the repo call in `React.cache` so the OG renderer and any future
- * page/generateMetadata pair share one Firestore read per request.
- */
-import { cache } from "react";
-import { productRepository } from "../../../../repositories";
-/**
- * Fetch a single prize-draw product by slug or id. Returns null when the
- * slug is empty or no matching product exists. The caller is responsible
- * for asserting `listingType === "prize-draw"` if a strict gate is required.
- */
-export const getPrizeDrawForDetail = cache(async (slugOrId, _opts) => {
-    void _opts;
-    if (!slugOrId)
-        return null;
-    return (await productRepository.findByIdOrSlug(slugOrId).catch(() => null)) ?? null;
-});
+import { makeGetListingForDetail } from "../shared/listing-data-factory";
+export const getPrizeDrawForDetail = makeGetListingForDetail("prize-draw");

package/dist/_internal/server/features/prize-draws/index.d.ts

@@ -1,2 +1,4 @@
-export { getPrizeDrawForDetail, type PrizeDrawDataOptions } from "./data";
+export { getPrizeDrawForDetail } from "./data";
+export { enterPrizeDrawAction } from "./actions";
+export { assertPrizeDrawOpen } from "./service";
 export { renderPrizeDrawOg, renderPrizeDrawOgImage, type PrizeDrawOgData, } from "./og";

package/dist/_internal/server/features/prize-draws/index.js

@@ -1,2 +1,4 @@
 export { getPrizeDrawForDetail } from "./data";
+export { enterPrizeDrawAction } from "./actions";
+export { assertPrizeDrawOpen } from "./service";
 export { renderPrizeDrawOg, renderPrizeDrawOgImage, } from "./og";

package/dist/_internal/server/features/prize-draws/service.d.ts

@@ -0,0 +1,3 @@
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+/** Assert the prize draw is accepting entries (published, reveal not started, slots not exhausted). */
+export declare function assertPrizeDrawOpen(product: ProductDocument): void;

package/dist/_internal/server/features/prize-draws/service.js

@@ -0,0 +1,19 @@
+import { ValidationError, CapacityError, ExpiredError } from "../../../shared/errors/index";
+/** Assert the prize draw is accepting entries (published, reveal not started, slots not exhausted). */
+export function assertPrizeDrawOpen(product) {
+    if (product.listingType !== "prize-draw") {
+        throw new ValidationError("Not a prize draw listing.");
+    }
+    if (product.status !== "published") {
+        throw new ValidationError("Prize draw is not active.");
+    }
+    const max = product.prizeMaxEntries ?? null;
+    const current = product.prizeCurrentEntries ?? 0;
+    if (typeof max === "number" && current >= max) {
+        throw new CapacityError("Prize draw is fully subscribed.");
+    }
+    const reveal = product.prizeRevealWindowStart;
+    if (reveal && new Date(reveal) <= new Date()) {
+        throw new ExpiredError("Prize draw entry window");
+    }
+}

package/dist/_internal/server/features/refunds/__tests__/actions.test.d.ts

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

package/dist/_internal/server/features/refunds/__tests__/actions.test.js

@@ -0,0 +1,263 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+// vi.hoisted: these must be declared before vi.mock factories reference them
+const { mockOrderFindById, mockPostRefundEvent, mockPaymentRefund, mockApplyRefundDeduction, mockCodesGet, } = vi.hoisted(() => {
+    const mockCodesQuery = {
+        where: vi.fn(),
+        limit: vi.fn(),
+        get: vi.fn(),
+    };
+    mockCodesQuery.where.mockReturnValue(mockCodesQuery);
+    mockCodesQuery.limit.mockReturnValue(mockCodesQuery);
+    return {
+        mockOrderFindById: vi.fn(),
+        mockPostRefundEvent: vi.fn(),
+        mockPaymentRefund: vi.fn(),
+        mockApplyRefundDeduction: vi.fn(),
+        mockCodesGet: mockCodesQuery.get,
+        _mockCodesQuery: mockCodesQuery,
+    };
+});
+// Mock appkit/server BEFORE other imports to avoid loading broken dist/client.js
+vi.mock("@mohasinac/appkit/server", () => ({
+    wrapAction: async (fn) => {
+        try {
+            const data = await fn();
+            return { ok: true, data };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { ok: false, error: msg };
+        }
+    },
+    isSoftBanned: vi.fn(() => false),
+}));
+vi.mock("../../../../../", () => ({
+    orderRepository: {
+        findById: mockOrderFindById,
+        postRefundEvent: mockPostRefundEvent,
+    },
+}));
+vi.mock("../../../../../contracts/registry", () => ({
+    getProviders: vi.fn(() => ({
+        payment: { refund: mockPaymentRefund },
+    })),
+}));
+// Mock the firebase-admin sub-module that provides getAdminDb
+// Chain: db.collection(PRODUCTS).doc(productId).collection(CODES).where("orderId","==",orderId).limit(1).get()
+vi.mock("../../../../../providers/db-firebase/admin", () => {
+    const mockCodesQuery = { where: vi.fn(), limit: vi.fn(), get: mockCodesGet };
+    mockCodesQuery.where.mockReturnValue(mockCodesQuery);
+    mockCodesQuery.limit.mockReturnValue(mockCodesQuery);
+    const mockCodesCollection = { where: vi.fn() };
+    mockCodesCollection.where.mockReturnValue(mockCodesQuery);
+    const mockDoc = { collection: vi.fn(() => mockCodesCollection) };
+    const mockTopCollection = { doc: vi.fn(() => mockDoc) };
+    const mockDb = { collection: vi.fn(() => mockTopCollection) };
+    return { getAdminDb: () => mockDb, getAdminAuth: vi.fn(), getAdminStorage: vi.fn() };
+});
+vi.mock("../../payouts/actions", () => ({
+    applyRefundDeductionAction: mockApplyRefundDeduction,
+}));
+vi.mock("../../../../../errors/normalize", () => ({ normalizeError: vi.fn() }));
+vi.mock("../../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}));
+import { processRefundAction } from "../actions";
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function makeOrder(overrides = {}) {
+    return {
+        id: "order-1",
+        storeId: "store-A",
+        totalPrice: 10000,
+        paymentMethod: "razorpay",
+        paymentId: "pay_abc123",
+        isNonRefundable: false,
+        items: [],
+        ...overrides,
+    };
+}
+function refundInput(overrides = {}) {
+    return {
+        orderId: "order-1",
+        type: "partial",
+        amountInPaise: 5000,
+        reason: "damaged item",
+        confirmIrrevocable: true,
+        refundedBy: "admin-uid",
+        method: "manual",
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockOrderFindById.mockResolvedValue(makeOrder());
+    mockPostRefundEvent.mockResolvedValue(undefined);
+    mockPaymentRefund.mockResolvedValue({ id: "rfnd_123" });
+    mockApplyRefundDeduction.mockResolvedValue(undefined);
+    mockCodesGet.mockResolvedValue({ empty: true, docs: [] });
+});
+// ─── Tests ──────────────────────────────────────────────────────────────────
+describe("processRefundAction — validation guards", () => {
+    it("order not found → ok: false", async () => {
+        mockOrderFindById.mockResolvedValue(null);
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/not found/i);
+    });
+    it("amount <= 0 → ok: false (validation)", async () => {
+        const result = await processRefundAction(refundInput({ amountInPaise: 0 }));
+        expect(result.ok).toBe(false);
+    });
+    it("negative amount → ok: false (validation)", async () => {
+        const result = await processRefundAction(refundInput({ amountInPaise: -100 }));
+        expect(result.ok).toBe(false);
+    });
+    it("amount > order.totalPrice → ok: false", async () => {
+        const result = await processRefundAction(refundInput({ amountInPaise: 10001 }));
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/exceeds/i);
+    });
+    it("amount === order.totalPrice → ok: true (full refund, not exceeds)", async () => {
+        const result = await processRefundAction(refundInput({ amountInPaise: 10000 }));
+        expect(result.ok).toBe(true);
+    });
+    it("isNonRefundable: true → ok: false", async () => {
+        mockOrderFindById.mockResolvedValue(makeOrder({ isNonRefundable: true }));
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/non-refundable/i);
+    });
+});
+describe("processRefundAction — digital code guard", () => {
+    it("digital code already claimed → ok: false", async () => {
+        mockOrderFindById.mockResolvedValue(makeOrder({
+            items: [{ productId: "digital-prod-1", listingType: "digital-code" }],
+        }));
+        mockCodesGet.mockResolvedValue({
+            empty: false,
+            docs: [{ data: () => ({ status: "claimed" }) }],
+        });
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(false);
+        expect(result.error).toMatch(/digital code|revealed/i);
+    });
+    it("digital code with status 'available' → refund allowed", async () => {
+        mockOrderFindById.mockResolvedValue(makeOrder({
+            items: [{ productId: "digital-prod-1", listingType: "digital-code" }],
+        }));
+        mockCodesGet.mockResolvedValue({
+            empty: false,
+            docs: [{ data: () => ({ status: "available" }) }],
+        });
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(true);
+    });
+    it("no digital code items → digital code check is skipped", async () => {
+        mockOrderFindById.mockResolvedValue(makeOrder({ items: [] }));
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(true);
+        expect(mockCodesGet).not.toHaveBeenCalled();
+    });
+    it("digital code collection query returns empty → refund allowed", async () => {
+        mockOrderFindById.mockResolvedValue(makeOrder({
+            items: [{ productId: "digital-prod-1", listingType: "digital-code" }],
+        }));
+        mockCodesGet.mockResolvedValue({ empty: true, docs: [] });
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(true);
+    });
+});
+describe("processRefundAction — Razorpay path", () => {
+    it("calls payment.refund with correct paymentId and amount", async () => {
+        const result = await processRefundAction(refundInput({
+            method: "razorpay",
+            razorpayPaymentId: "pay_abc123",
+            amountInPaise: 5000,
+        }));
+        expect(result.ok).toBe(true);
+        expect(mockPaymentRefund).toHaveBeenCalledWith("pay_abc123", 5000);
+    });
+    it("Razorpay refund API failure → ok: false, postRefundEvent NOT called", async () => {
+        mockPaymentRefund.mockRejectedValue(new Error("Razorpay API error"));
+        const result = await processRefundAction(refundInput({
+            method: "razorpay",
+            razorpayPaymentId: "pay_abc123",
+        }));
+        expect(result.ok).toBe(false);
+        expect(mockPostRefundEvent).not.toHaveBeenCalled();
+    });
+    it("razorpayRefundId from provider is stored in event", async () => {
+        mockPaymentRefund.mockResolvedValue({ id: "rfnd_xyz789" });
+        await processRefundAction(refundInput({
+            method: "razorpay",
+            razorpayPaymentId: "pay_abc123",
+        }));
+        expect(mockPostRefundEvent).toHaveBeenCalledWith("order-1", expect.objectContaining({ razorpayRefundId: "rfnd_xyz789" }), expect.any(Boolean));
+    });
+});
+describe("processRefundAction — manual path", () => {
+    it("does NOT call payment.refund for manual refunds", async () => {
+        await processRefundAction(refundInput({ method: "manual" }));
+        expect(mockPaymentRefund).not.toHaveBeenCalled();
+    });
+    it("calls postRefundEvent without razorpayRefundId", async () => {
+        await processRefundAction(refundInput({ method: "manual" }));
+        const event = mockPostRefundEvent.mock.calls[0][1];
+        expect(event.razorpayRefundId).toBeUndefined();
+    });
+    it("stores manualTransactionId when provided", async () => {
+        await processRefundAction(refundInput({ method: "manual", manualTransactionId: "TXN123" }));
+        const event = mockPostRefundEvent.mock.calls[0][1];
+        expect(event.manualTransactionId).toBe("TXN123");
+    });
+});
+describe("processRefundAction — success path", () => {
+    it("calls orderRepository.postRefundEvent with correct orderId", async () => {
+        await processRefundAction(refundInput());
+        expect(mockPostRefundEvent).toHaveBeenCalledWith("order-1", expect.any(Object), expect.any(Boolean));
+    });
+    it("partial amount: isFull = false passed to postRefundEvent", async () => {
+        await processRefundAction(refundInput({ amountInPaise: 5000 }));
+        const isFull = mockPostRefundEvent.mock.calls[0][2];
+        expect(isFull).toBe(false);
+    });
+    it("full amount: isFull = true passed to postRefundEvent", async () => {
+        await processRefundAction(refundInput({ amountInPaise: 10000 }));
+        const isFull = mockPostRefundEvent.mock.calls[0][2];
+        expect(isFull).toBe(true);
+    });
+    it("returns ok: true with success: true and a refundId UUID", async () => {
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(true);
+        const data = result.data;
+        expect(data.success).toBe(true);
+        expect(data.refundId).toMatch(/^[0-9a-f-]{36}$/i);
+    });
+    it("event contains reason, refundedBy, and refundedAt", async () => {
+        await processRefundAction(refundInput({ reason: "broken product", refundedBy: "admin-1" }));
+        const event = mockPostRefundEvent.mock.calls[0][1];
+        expect(event.reason).toBe("broken product");
+        expect(event.refundedBy).toBe("admin-1");
+        expect(event.refundedAt).toBeInstanceOf(Date);
+    });
+});
+describe("processRefundAction — payout deduction", () => {
+    it("triggers applyRefundDeductionAction when order has storeId", async () => {
+        await processRefundAction(refundInput({ amountInPaise: 5000 }));
+        expect(mockApplyRefundDeduction).toHaveBeenCalledWith(expect.objectContaining({
+            storeId: "store-A",
+            orderId: "order-1",
+            refundedAmountInPaise: 5000,
+        }));
+    });
+    it("does NOT call applyRefundDeductionAction when order has no storeId", async () => {
+        mockOrderFindById.mockResolvedValue(makeOrder({ storeId: undefined }));
+        await processRefundAction(refundInput());
+        expect(mockApplyRefundDeduction).not.toHaveBeenCalled();
+    });
+    it("deduction failure does NOT fail the refund (fire-and-forget)", async () => {
+        mockApplyRefundDeduction.mockRejectedValue(new Error("Payout service unavailable"));
+        const result = await processRefundAction(refundInput());
+        expect(result.ok).toBe(true);
+    });
+});

package/dist/_internal/server/features/shared/listing-adapters.d.ts

@@ -0,0 +1,19 @@
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+export interface BaseListingClientShape {
+    id: string;
+    title: string;
+    description: string;
+    price: number;
+    priceLabel: string;
+    currency: string;
+    mainImage: string | null;
+    images: string[];
+    storeId: string;
+    storeName: string | null;
+    category: string;
+    tags: string[];
+    status: ProductDocument["status"];
+    createdAt: string;
+}
+/** Maps the 11 shared fields from a raw Firestore ProductDocument. */
+export declare function mapBaseListingFields(doc: ProductDocument): BaseListingClientShape;

package/dist/_internal/server/features/shared/listing-adapters.js

@@ -0,0 +1,20 @@
+import { formatCurrency } from "../../../../utils/number.formatter";
+/** Maps the 11 shared fields from a raw Firestore ProductDocument. */
+export function mapBaseListingFields(doc) {
+    return {
+        id: doc.id,
+        title: doc.title,
+        description: doc.description,
+        price: doc.price,
+        priceLabel: formatCurrency(doc.price, doc.currency ?? "INR"),
+        currency: doc.currency ?? "INR",
+        mainImage: doc.mainImage || doc.images?.[0] || null,
+        images: doc.images ?? [],
+        storeId: doc.storeId,
+        storeName: doc.storeName ?? null,
+        category: doc.categorySlugs?.[0] ?? doc.category ?? "",
+        tags: doc.tags ?? [],
+        status: doc.status,
+        createdAt: doc.createdAt instanceof Date ? doc.createdAt.toISOString() : String(doc.createdAt),
+    };
+}

package/dist/_internal/server/features/shared/listing-data-factory.d.ts

@@ -0,0 +1,9 @@
+import type { ListingType } from "../../../../features/products/types";
+import type { ProductDocument } from "../../../../features/products/schemas/firestore";
+import type { ProductFeatureDocument } from "../../../../features/products/schemas/product-features";
+export declare function makeGetListingForDetail(type: ListingType): (slugOrId: string) => Promise<ProductDocument | null>;
+export declare const getProductFeaturesForStore: (storeId: string | null) => Promise<ProductFeatureDocument[]>;
+export declare function makeGetStoreListingsInitial(type: ListingType, pageSize: number): (storeId: string, page?: number) => Promise<{
+    items: ProductDocument[];
+    total: number;
+}>;

package/dist/_internal/server/features/shared/listing-data-factory.js

@@ -0,0 +1,33 @@
+import { cache } from "react";
+import { productRepository } from "../../../../repositories";
+import { loadProductFeaturesForStore } from "../../../../features/products/repository/loadProductFeatures";
+// Returns a React.cache()-wrapped fetch gated on one listing type.
+// The guard prevents cross-type URL collisions (e.g. /auctions/classified-slug returning wrong product).
+export function makeGetListingForDetail(type) {
+    return cache(async (slugOrId) => {
+        if (!slugOrId)
+            return null;
+        const product = await productRepository.findByIdOrSlug(slugOrId).catch(() => undefined);
+        if (!product || product.listingType !== type)
+            return null;
+        return product;
+    });
+}
+// Product-feature badges are keyed by store, not listing type.
+// Per-type data.ts files re-export this under a type-specific name.
+export const getProductFeaturesForStore = cache(async (storeId) => loadProductFeaturesForStore(storeId).catch(() => []));
+// Returns a React.cache()-wrapped function for store SSR first-page data.
+// Export names in stores/data.ts stay identical so consumers need no changes.
+export function makeGetStoreListingsInitial(type, pageSize) {
+    return cache(async (storeId, page = 1) => {
+        const result = await productRepository
+            .list({
+            filters: `storeId==${storeId},status==published,listingType==${type}`,
+            sorts: "-createdAt",
+            page,
+            pageSize,
+        })
+            .catch(() => null);
+        return { items: result?.items ?? [], total: result?.total ?? 0 };
+    });
+}

package/dist/_internal/server/features/stores/data.d.ts

@@ -1,27 +1,16 @@
 import type { StoreDocument } from "../../../../features/stores/schemas/firestore";
-import type { ProductDocument } from "../../../../features/products/schemas/firestore";
 /** Full store document by slug — deduped per request via React.cache(). */
 export declare const getStoreForDetail: (slug: string) => Promise<StoreDocument | null>;
-/**
- * Published products for a store detail page.
- * Returns the first page used for SSR initial data.
- */
 export declare const listStoreProductsInitial: (storeId: string, page?: number) => Promise<{
-    items: ProductDocument[];
+    items: import("../../../..").ProductDocument[];
     total: number;
 }>;
-/**
- * Published auctions for a store detail page.
- */
 export declare const listStoreAuctionsInitial: (storeId: string, page?: number) => Promise<{
-    items: ProductDocument[];
+    items: import("../../../..").ProductDocument[];
     total: number;
 }>;
-/**
- * Published pre-orders for a store detail page.
- */
 export declare const listStorePreOrdersInitial: (storeId: string, page?: number) => Promise<{
-    items: ProductDocument[];
+    items: import("../../../..").ProductDocument[];
     total: number;
 }>;
 /** Stores for sitemap generation. */

package/dist/_internal/server/features/stores/data.js

@@ -1,54 +1,16 @@
 "use server";
 import { cache } from "react";
-import { storeRepository, productRepository } from "../../../../repositories";
+import { storeRepository } from "../../../../repositories";
 import { STORES_PRODUCTS_PAGE_SIZE, STORES_SITEMAP_LIMIT, } from "../../../shared/features/stores/config";
+import { makeGetStoreListingsInitial } from "../shared/listing-data-factory";
 /** Full store document by slug — deduped per request via React.cache(). */
 export const getStoreForDetail = cache(async (slug) => {
     return (await storeRepository.findBySlug(slug).catch(() => undefined)) ?? null;
 });
-/**
- * Published products for a store detail page.
- * Returns the first page used for SSR initial data.
- */
-export const listStoreProductsInitial = cache(async (storeId, page = 1) => {
-    const result = await productRepository
-        .list({
-        filters: `storeId==${storeId},status==published,listingType==standard`,
-        sorts: "-createdAt",
-        page,
-        pageSize: STORES_PRODUCTS_PAGE_SIZE,
-    })
-        .catch(() => null);
-    return { items: result?.items ?? [], total: result?.total ?? 0 };
-});
-/**
- * Published auctions for a store detail page.
- */
-export const listStoreAuctionsInitial = cache(async (storeId, page = 1) => {
-    const result = await productRepository
-        .list({
-        filters: `storeId==${storeId},status==published,listingType==auction`,
-        sorts: "-createdAt",
-        page,
-        pageSize: STORES_PRODUCTS_PAGE_SIZE,
-    })
-        .catch(() => null);
-    return { items: result?.items ?? [], total: result?.total ?? 0 };
-});
-/**
- * Published pre-orders for a store detail page.
- */
-export const listStorePreOrdersInitial = cache(async (storeId, page = 1) => {
-    const result = await productRepository
-        .list({
-        filters: `storeId==${storeId},status==published,listingType==pre-order`,
-        sorts: "-createdAt",
-        page,
-        pageSize: STORES_PRODUCTS_PAGE_SIZE,
-    })
-        .catch(() => null);
-    return { items: result?.items ?? [], total: result?.total ?? 0 };
-});
+// Collapse of three near-identical 14-line functions via factory — export names unchanged.
+export const listStoreProductsInitial = makeGetStoreListingsInitial("standard", STORES_PRODUCTS_PAGE_SIZE);
+export const listStoreAuctionsInitial = makeGetStoreListingsInitial("auction", STORES_PRODUCTS_PAGE_SIZE);
+export const listStorePreOrdersInitial = makeGetStoreListingsInitial("pre-order", STORES_PRODUCTS_PAGE_SIZE);
 /** Stores for sitemap generation. */
 export const listSitemapStores = cache(async () => {
     const result = await storeRepository

package/dist/_internal/server/jobs/core/__tests__/auctionSettlement.test.d.ts

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