@mohasinac/appkit 4.1.1 → 4.2.0

package/dist/_internal/server/features/maintenance/cloud-logs-data.js

@@ -0,0 +1,152 @@
+/**
+ * Google Cloud Logging integration for the `/admin/maintenance/cloud-logs`
+ * page. Reuses the same 3-tier credential resolution as
+ * `providers/db-firebase/admin.ts` (local `firebase-admin-key.json` → Vercel
+ * `FIREBASE_ADMIN_*` env vars → Application Default Credentials), so no new
+ * env vars are required.
+ *
+ * Bounded to ONE `Logging#getEntries()` call per invocation — never
+ * `getEntriesStream()` in an unbounded loop — to respect the Vercel Hobby
+ * 10s sync-function ceiling (CLAUDE.md Rule #6). Pagination is client-driven
+ * via `nextPageToken`, not exhausted server-side.
+ *
+ * `@google-cloud/logging` is a consumer-side (root `package.json`) dependency
+ * — it is never imported at module scope here. The `Logging` client is
+ * lazily `require()`d inside a function body via `(module as any).require`,
+ * exactly like `admin.ts` lazily loads `firebase-admin/*`, so Turbopack never
+ * sees a static import of a Node-only client reachable from a client bundle
+ * (CLAUDE.md Root Cause #6 / #24). A minimal local interface describes the
+ * only surface we call — this file never imports `@google-cloud/logging`'s
+ * own types, so it type-checks even though the package is deliberately not
+ * listed as an appkit dependency (it lives in the consumer's root
+ * `package.json` only, since this integration is Next.js-route-only).
+ */
+import { cache } from "react";
+import { parsePrivateKey } from "../../../../providers/db-firebase/admin";
+function loadLogging() {
+    return module.require("@google-cloud/logging");
+}
+function nodePath() { return require("path"); }
+function nodeFs() { return require("fs"); }
+// process.cwd() is Node.js-only; access via module.require so the Edge
+// static analyser does not flag this file (mirrors admin.ts).
+function nodeCwd() { return module.require("process").cwd(); }
+// Plain module-scope singleton (not `declare global` + `globalThis`) — this
+// module is only ever reachable through one resolution path per process, so
+// a module-local cache is sufficient and avoids global-augmentation clashes
+// when the same declaration is picked up from both compiled `.d.ts` output
+// and live source under a `file:./appkit` consumer tsconfig include.
+let cachedLoggingClient = null;
+function getCached() {
+    return cachedLoggingClient;
+}
+function setCached(client) {
+    cachedLoggingClient = client;
+}
+function getLoggingClient() {
+    const cached = getCached();
+    if (cached)
+        return cached;
+    const { Logging } = loadLogging();
+    const keyPath = nodePath().join(nodeCwd(), "firebase-admin-key.json");
+    let client;
+    if (nodeFs().existsSync(keyPath)) {
+        // Local dev — the JSON key file also carries project_id, so the Logging
+        // client resolves the project automatically from `keyFilename`.
+        client = new Logging({ keyFilename: keyPath });
+    }
+    else if (process.env.FIREBASE_ADMIN_PROJECT_ID &&
+        process.env.FIREBASE_ADMIN_CLIENT_EMAIL &&
+        process.env.FIREBASE_ADMIN_PRIVATE_KEY) {
+        // Vercel — same three env vars the Firebase Admin SDK uses.
+        client = new Logging({
+            projectId: process.env.FIREBASE_ADMIN_PROJECT_ID.trim(),
+            credentials: {
+                client_email: process.env.FIREBASE_ADMIN_CLIENT_EMAIL.trim(),
+                private_key: parsePrivateKey(process.env.FIREBASE_ADMIN_PRIVATE_KEY),
+            },
+        });
+    }
+    else if (
+    // Application Default Credentials — Firebase Functions / Cloud Run / GCE.
+    process.env.FUNCTION_TARGET ||
+        process.env.K_SERVICE ||
+        process.env.FIREBASE_CONFIG ||
+        process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+        const firebaseConfig = process.env.FIREBASE_CONFIG
+            ? JSON.parse(process.env.FIREBASE_CONFIG)
+            : {};
+        const projectId = firebaseConfig.projectId ?? process.env.GCLOUD_PROJECT;
+        client = new Logging(projectId ? { projectId } : {});
+    }
+    else {
+        throw new Error("@mohasinac/appkit: Cloud Logging credentials not found.\n" +
+            "Add firebase-admin-key.json to project root, or set " +
+            "FIREBASE_ADMIN_PROJECT_ID, FIREBASE_ADMIN_CLIENT_EMAIL, " +
+            "FIREBASE_ADMIN_PRIVATE_KEY environment variables.");
+    }
+    setCached(client);
+    return client;
+}
+const DEFAULT_WINDOW_HOURS = 24;
+const MAX_PAGE_SIZE = 100;
+const DEFAULT_PAGE_SIZE = 50;
+/**
+ * This project's Firebase Functions are all 2nd-gen
+ * (`firebase-functions/v2/*` — see
+ * `_internal/server/functions/bind-all.ts` + `jobs/runtime/adapters/firebase.ts`,
+ * which import exclusively from `firebase-functions/v2/{scheduler,firestore,https}`).
+ * 2nd-gen Functions run on Cloud Run under the hood, so their log entries
+ * carry `resource.type="cloud_run_revision"` — NOT the 1st-gen
+ * `"cloud_function"` resource type.
+ */
+const DEFAULT_RESOURCE_TYPE = "cloud_run_revision";
+function buildDefaultFilter() {
+    const since = new Date(Date.now() - DEFAULT_WINDOW_HOURS * 3600000).toISOString();
+    return `resource.type="${DEFAULT_RESOURCE_TYPE}" AND timestamp>="${since}"`;
+}
+function excerpt(value, max = 300) {
+    if (value === null || value === undefined || value === "")
+        return "";
+    const text = typeof value === "string" ? value : JSON.stringify(value);
+    return text.length > max ? text.slice(0, max) + "…" : text;
+}
+function toCloudLogEntry(raw, index) {
+    const metadata = raw.metadata ?? {};
+    const tsRaw = metadata.timestamp;
+    const timestamp = tsRaw instanceof Date
+        ? tsRaw.toISOString()
+        : typeof tsRaw === "string"
+            ? tsRaw
+            : new Date().toISOString();
+    const resource = metadata.resource ?? {};
+    return {
+        id: metadata.insertId ?? `${timestamp}-${index}`,
+        timestamp,
+        severity: String(metadata.severity ?? "DEFAULT"),
+        resourceType: resource.type ?? "unknown",
+        resourceLabels: resource.labels ?? {},
+        logName: metadata.logName ?? "",
+        message: excerpt(raw.data),
+    };
+}
+/**
+ * Bounded, single-page Cloud Logging read. One `getEntries()` call per
+ * invocation — the caller drives further pages via `opts.pageToken`
+ * (client-side "Load more"), never a server-side exhaust loop.
+ */
+export const listCloudLogEntries = cache(async (opts = {}) => {
+    const pageSize = Math.min(Math.max(opts.pageSize ?? DEFAULT_PAGE_SIZE, 1), MAX_PAGE_SIZE);
+    const filter = opts.filter?.trim() ? opts.filter.trim() : buildDefaultFilter();
+    const logging = getLoggingClient();
+    const [entries, , apiResponse] = await logging.getEntries({
+        filter,
+        pageSize,
+        orderBy: "timestamp desc",
+        ...(opts.pageToken ? { pageToken: opts.pageToken } : {}),
+    });
+    return {
+        entries: entries.map((e, i) => toCloudLogEntry(e, i)),
+        nextPageToken: apiResponse?.nextPageToken || null,
+    };
+});

package/dist/_internal/server/functions/scheduled.d.ts

@@ -6,6 +6,7 @@ export declare const paymentReviewAutoApprove: import("./types").ScheduledFuncti
 export declare const couponExpiry: import("./types").ScheduledFunctionDefinition;
 export declare const offerExpiry: import("./types").ScheduledFunctionDefinition;
 export declare const productStatsSync: import("./types").ScheduledFunctionDefinition;
+export declare const revenueRollup: import("./types").ScheduledFunctionDefinition;
 export declare const dailyDataCleanup: import("./types").ScheduledFunctionDefinition;
 export declare const countersReconcile: import("./types").ScheduledFunctionDefinition;
 export declare const positionsReconcile: import("./types").ScheduledFunctionDefinition;
@@ -25,4 +26,4 @@ export declare const prizeRevealReminder: import("./types").ScheduledFunctionDef
 export declare const bundleStockSync: import("./types").ScheduledFunctionDefinition;
 export declare const emiInstallmentReminder: import("./types").ScheduledFunctionDefinition;
 export declare const catalogueImageStalenessReminder: import("./types").ScheduledFunctionDefinition;
-export declare const SCHEDULED_FUNCTIONS: readonly [import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition];
+export declare const SCHEDULED_FUNCTIONS: readonly [import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition, import("./types").ScheduledFunctionDefinition];

package/dist/_internal/server/functions/scheduled.js

@@ -1,6 +1,6 @@
 // Scheduled function definitions (Cloud Scheduler triggers).
 // Cron syntax accepts both Firebase shorthand and standard cron expressions.
-import { auctionSettlementHandler, autoPayoutEligibilityHandler, bundleStockSyncHandler, cartPruneHandler, cleanupRtdbEventsHandler, countersReconcileHandler, couponExpiryHandler, dailyDataCleanupHandler, draftPruneHandler, emiInstallmentReminderHandler, catalogueImageStalenessReminderHandler, mediaTmpCleanupHandler, notificationPruneHandler, offerExpiryHandler, payoutBatchHandler, paymentWindowTimeoutHandler, hardBanReinstatementHandler, paymentReviewAutoApproveHandler, pendingOrderTimeoutHandler, positionsReconcileHandler, prizeRevealCloseHandler, prizeRevealExpiryHandler, prizeRevealOpenHandler, prizeRevealReminderHandler, productStatsSyncHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, } from "../jobs/handlers";
+import { auctionSettlementHandler, autoPayoutEligibilityHandler, bundleStockSyncHandler, cartPruneHandler, cleanupRtdbEventsHandler, countersReconcileHandler, couponExpiryHandler, dailyDataCleanupHandler, draftPruneHandler, emiInstallmentReminderHandler, catalogueImageStalenessReminderHandler, mediaTmpCleanupHandler, notificationPruneHandler, offerExpiryHandler, payoutBatchHandler, paymentWindowTimeoutHandler, hardBanReinstatementHandler, paymentReviewAutoApproveHandler, pendingOrderTimeoutHandler, positionsReconcileHandler, prizeRevealCloseHandler, prizeRevealExpiryHandler, prizeRevealOpenHandler, prizeRevealReminderHandler, productStatsSyncHandler, revenueRollupHandler, weeklyPayoutEligibilityHandler, testerSandboxCleanupHandler, } from "../jobs/handlers";
 import { defineFunction } from "./define";
 const REGION = "asia-south1";
 const EVERY_5_MIN = "every 5 minutes";
@@ -60,6 +60,13 @@ export const productStatsSync = defineFunction({
     handler: productStatsSyncHandler,
     options: { region: REGION, timeoutSeconds: 540, memory: "256MiB", maxInstances: 1 },
 });
+export const revenueRollup = defineFunction({
+    name: "revenueRollup",
+    description: "Pre-compute total delivered-order revenue into analytics/dashboardRollup, replacing an unbounded per-request scan (daily 01:30 UTC).",
+    trigger: { kind: "schedule", cron: "30 1 * * *", timeZone: "UTC" },
+    handler: revenueRollupHandler,
+    options: { region: REGION, timeoutSeconds: 300, memory: "256MiB", maxInstances: 1 },
+});
 export const dailyDataCleanup = defineFunction({
     name: "dailyDataCleanup",
     description: "Daily data cleanup (drafts, transient records) at 02:00 UTC.",
@@ -202,6 +209,7 @@ export const SCHEDULED_FUNCTIONS = [
     couponExpiry,
     offerExpiry,
     productStatsSync,
+    revenueRollup,
     dailyDataCleanup,
     countersReconcile,
     positionsReconcile,

package/dist/_internal/server/jobs/core/jobRunners.js

@@ -11,6 +11,8 @@
 import { runWeeklyPayoutEligibility } from "./weeklyPayoutEligibility";
 import { runHardBanCascade } from "./hardBanCascade";
 import { runResetOtpVerification } from "./resetOtpVerification";
+import { runWhatsAppNotify } from "./whatsappNotify";
+import { runNewsletterExport } from "./newsletterExport";
 async function runPayoutsWeeklyJob(_payload, ctx) {
     const { payoutsCreated, ordersProcessed, payoutIds } = await runWeeklyPayoutEligibility(ctx);
     return {
@@ -37,8 +39,16 @@ async function runHardBanCascadeJob(payload, ctx) {
 async function runResetOtpVerificationJob(_payload, ctx) {
     return runResetOtpVerification(ctx);
 }
+async function runWhatsAppNotifyJob(payload, ctx) {
+    return runWhatsAppNotify(payload, ctx);
+}
+async function runNewsletterExportJob(_payload, ctx) {
+    return runNewsletterExport(ctx);
+}
 export const JOB_RUNNERS = {
     payoutsWeekly: runPayoutsWeeklyJob,
     hardBanCascade: runHardBanCascadeJob,
     resetOtpVerification: runResetOtpVerificationJob,
+    whatsappNotify: runWhatsAppNotifyJob,
+    newsletterExport: runNewsletterExportJob,
 };

package/dist/_internal/server/jobs/core/newsletterExport.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core: async newsletter-subscriber CSV export (`newsletterExport` job).
+ *
+ * `GET /api/admin/newsletter/export` used to build the full CSV in-process,
+ * synchronously, for up to 10,000 subscribers — a real 10s-timeout risk on
+ * Vercel Hobby as the list grows (CLAUDE.md Rule #6). This runner does the
+ * same work inside a Firebase Function instead and writes the CSV text onto
+ * the job's `result.data.csv` field — small enough for a Firestore doc at
+ * realistic subscriber counts, and avoids routing through Storage (which
+ * would need a `/media/...` proxy URL per the Media Architecture rules
+ * rather than a raw signed URL).
+ */
+import type { JobContext } from "../runtime/types";
+import type { JobRunResult } from "./jobRunners";
+export declare function runNewsletterExport(ctx: JobContext): Promise<JobRunResult>;

package/dist/_internal/server/jobs/core/newsletterExport.js

@@ -0,0 +1,43 @@
+/**
+ * Core: async newsletter-subscriber CSV export (`newsletterExport` job).
+ *
+ * `GET /api/admin/newsletter/export` used to build the full CSV in-process,
+ * synchronously, for up to 10,000 subscribers — a real 10s-timeout risk on
+ * Vercel Hobby as the list grows (CLAUDE.md Rule #6). This runner does the
+ * same work inside a Firebase Function instead and writes the CSV text onto
+ * the job's `result.data.csv` field — small enough for a Firestore doc at
+ * realistic subscriber counts, and avoids routing through Storage (which
+ * would need a `/media/...` proxy URL per the Media Architecture rules
+ * rather than a raw signed URL).
+ */
+import { newsletterRepository } from "../../../../repositories";
+import { sortBy } from "../../../../constants/sort";
+import { COMMON_FIELDS } from "../../../../constants/field-names";
+function escape(value) {
+    const s = String(value ?? "");
+    return s.includes(",") || s.includes('"') || s.includes("\n")
+        ? `"${s.replace(/"/g, '""')}"`
+        : s;
+}
+function csvRow(cols) {
+    return cols.map(escape).join(",");
+}
+export async function runNewsletterExport(ctx) {
+    const result = await newsletterRepository.list({
+        sorts: sortBy(COMMON_FIELDS.CREATED_AT),
+        page: "1",
+        pageSize: "10000",
+    });
+    const rows = result.data;
+    const header = csvRow(["id", "email", "status", "source", "subscribedAt", "createdAt"]);
+    const dataRows = rows.map((s) => csvRow([s["id"], s["email"] ?? "", s["status"] ?? "", s["source"] ?? "", s["subscribedAt"] ?? "", s["createdAt"] ?? ""]));
+    const csv = [header, ...dataRows].join("\r\n");
+    ctx.logger.info("newsletterExport: complete", { subscriberCount: rows.length });
+    return {
+        summary: { total: rows.length, succeeded: rows.length, skipped: 0, failed: 0 },
+        succeeded: [],
+        skipped: [],
+        failed: [],
+        data: { csv, subscriberCount: rows.length },
+    };
+}

package/dist/_internal/server/jobs/core/onOrderCreate.d.ts

@@ -1,18 +1,10 @@
 import type { JobContext } from "../runtime/types";
-interface OrderItem {
-    title?: string;
-    name?: string;
-}
-export interface NewOrder {
-    buyerDisplayName?: string;
-    buyerId?: string;
-    items?: OrderItem[];
-    totalAmount?: number;
-    storeId?: string;
-}
+import type { OrderDocument, OrderDocumentItem } from "../../../../features/orders/schemas/firestore";
+export type NewOrder = Pick<OrderDocument, "userName" | "userId" | "totalPrice" | "storeId"> & {
+    items?: Pick<OrderDocumentItem, "productTitle">[];
+};
 export interface HandleOrderCreateInput {
     orderId: string;
     order: NewOrder;
 }
 export declare function handleOrderCreate(input: HandleOrderCreateInput, ctx: JobContext): Promise<void>;
-export {};

package/dist/_internal/server/jobs/core/onOrderCreate.js

@@ -54,14 +54,14 @@ export async function handleOrderCreate(input, ctx) {
     }
     const items = order.items ?? [];
     const firstItem = items[0];
-    const firstItemName = firstItem?.title ?? firstItem?.name ?? "an item";
+    const firstItemName = firstItem?.productTitle ?? "an item";
     const additionalItemCount = Math.max(0, items.length - 1);
-    const buyerName = order.buyerDisplayName ?? "A customer";
+    const buyerName = order.userName ?? "A customer";
     const message = buildPurchaseAnnouncementMessage({
         buyerName,
         firstItemName,
         additionalItemCount,
-        totalAmount: order.totalAmount ?? 0,
+        totalAmount: order.totalPrice ?? 0,
         orderId,
     });
     const adminNumbersRaw = ctx.env("WHATSAPP_ADMIN_NOTIFY_NUMBERS") ?? "";

package/dist/_internal/server/jobs/core/onOrderStatusChange.d.ts

@@ -6,6 +6,8 @@ export type OrderAfter = {
     userEmail: string;
     productTitle: string;
     trackingNumber?: string;
+    /** Buyer opted into the ₹10 WhatsApp order-updates addon at checkout. */
+    whatsappNotifyAddon?: boolean;
 };
 export type OrderBefore = {
     status: OrderStatus;

package/dist/_internal/server/jobs/core/onOrderStatusChange.js

@@ -56,6 +56,7 @@ export async function handleOrderStatusChange(input, ctx) {
             relatedId: orderId,
             relatedType: "order",
             userEmail,
+            orderWhatsappAddonPaid: after.whatsappNotifyAddon === true,
         });
         try {
             await getAdminRealtimeDb().ref(`notifications/${after.userId}`).push({

package/dist/_internal/server/jobs/core/onProductWrite.js

@@ -10,6 +10,14 @@ const UNAVAILABLE_PRODUCT_STATUSES = new Set([
     ProductStatusValues.ARCHIVED,
 ]);
 void UNAVAILABLE_PRODUCT_STATUSES;
+function getEffectiveCategory(doc) {
+    if (!doc)
+        return null;
+    const categorySlugs = doc.categorySlugs;
+    if (Array.isArray(categorySlugs) && categorySlugs.length > 0)
+        return categorySlugs[0];
+    return doc.category ?? null;
+}
 async function getParentIds(categoryId) {
     if (!categoryId)
         return [];
@@ -63,8 +71,12 @@ export async function handleProductWrite(input, ctx) {
     const { productId, before, after } = input;
     const beforeStatus = before?.status ?? null;
     const afterStatus = after?.status ?? null;
-    const beforeCategory = before?.category ?? null;
-    const afterCategory = after?.category ?? null;
+    // `category` is @deprecated in favor of `categorySlugs[]` — the repository's
+    // mapDoc() normalizes this on read, but a raw trigger snapshot bypasses that,
+    // so a product written via categorySlugs-only paths would otherwise silently
+    // no-op category metrics here. Prefer categorySlugs[0], fall back to legacy category.
+    const beforeCategory = getEffectiveCategory(before);
+    const afterCategory = getEffectiveCategory(after);
     const beforeStoreId = (before?.storeId || before?.sellerId) ?? null;
     const afterStoreId = (after?.storeId || after?.sellerId) ?? null;
     const isAuction = after?.listingType === PRODUCT_FIELDS.LISTING_TYPE_VALUES.AUCTION;

package/dist/_internal/server/jobs/core/paymentWindowTimeout.js

@@ -51,6 +51,7 @@ export async function runPaymentWindowTimeout(ctx) {
         message: ORDER_MESSAGES.CANCELLED_PAYMENT_WINDOW_MESSAGE(entry.data.productTitle),
         relatedId: entry.id,
         relatedType: "order",
+        orderWhatsappAddonPaid: entry.data.whatsappNotifyAddon === true,
     })));
     ctx.logger.info("Payment window timeout sweep complete", {
         scanned: expired.length,

package/dist/_internal/server/jobs/core/pendingOrderTimeout.js

@@ -49,6 +49,7 @@ export async function runPendingOrderTimeout(ctx) {
         message: ORDER_MESSAGES.CANCELLED_TIMEOUT_MESSAGE(entry.data.productTitle, timeoutHours),
         relatedId: entry.id,
         relatedType: "order",
+        orderWhatsappAddonPaid: entry.data.whatsappNotifyAddon === true,
     })));
     ctx.logger.info("Pending order timeout complete", { cancelled: timedOut.length, restored });
 }

package/dist/_internal/server/jobs/core/revenueRollup.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Core: daily revenue rollup.
+ *
+ * `GET /api/admin/dashboard` used to sum `totalPrice` over the FULL
+ * `delivered`-status orders list on every request (`orderRepository.findByStatus`
+ * has no bound) — a real, growing Firestore-read cost and a 10s-timeout risk
+ * on Vercel Hobby (CLAUDE.md Rule #6) as order volume increases. This job
+ * pre-computes the same aggregate once a day and writes it to the
+ * `analytics/dashboardRollup` singleton doc; the API route now reads that
+ * single doc instead of scanning the collection.
+ */
+import type { JobContext } from "../runtime/types";
+export declare function runRevenueRollup(ctx: JobContext): Promise<void>;

package/dist/_internal/server/jobs/core/revenueRollup.js

@@ -0,0 +1,22 @@
+/**
+ * Core: daily revenue rollup.
+ *
+ * `GET /api/admin/dashboard` used to sum `totalPrice` over the FULL
+ * `delivered`-status orders list on every request (`orderRepository.findByStatus`
+ * has no bound) — a real, growing Firestore-read cost and a 10s-timeout risk
+ * on Vercel Hobby (CLAUDE.md Rule #6) as order volume increases. This job
+ * pre-computes the same aggregate once a day and writes it to the
+ * `analytics/dashboardRollup` singleton doc; the API route now reads that
+ * single doc instead of scanning the collection.
+ */
+import { orderRepository } from "../../../../repositories";
+import { analyticsRollupRepository } from "../../../../repositories";
+export async function runRevenueRollup(ctx) {
+    const deliveredOrders = await orderRepository.findByStatus("delivered").catch(() => []);
+    const totalRevenue = deliveredOrders.reduce((sum, order) => sum + (Number(order.totalPrice ?? 0) || 0), 0);
+    await analyticsRollupRepository.setDashboardRollup({
+        totalRevenue,
+        deliveredOrderCount: deliveredOrders.length,
+    });
+    ctx.logger.info("revenueRollup: complete", { totalRevenue, deliveredOrderCount: deliveredOrders.length });
+}

package/dist/_internal/server/jobs/core/whatsappNotify.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Core: async WhatsApp notification dispatch (`whatsappNotify` job).
+ *
+ * `sendNotification()` (appkit/src/features/admin/actions/notification-actions.ts)
+ * no longer calls the Meta Cloud API synchronously in-request — it enqueues
+ * this job instead (CLAUDE.md Rule #6 async job primitive) and returns
+ * immediately. This runner does the actual send, with a bounded retry, and
+ * writes the outcome back onto `notifications/{notificationId}` so admins
+ * have visibility beyond the `jobs/{jobId}` doc itself.
+ *
+ * Retry note: `sendWhatsAppTemplateMessage`/`sendWhatsAppBusinessMessage`
+ * return a plain boolean (not a status code), so this runner cannot cleanly
+ * distinguish a transient 5xx from a terminal 4xx (bad token, unknown
+ * template) the way a status-code-aware client could. It retries any
+ * failure up to MAX_ATTEMPTS with a short backoff — an acceptable
+ * simplification since this runs off the critical path, well inside the
+ * Firebase Function's 300s budget, and a terminal error just burns two
+ * extra fast failures before giving up.
+ */
+import type { JobContext } from "../runtime/types";
+import type { JobRunResult } from "./jobRunners";
+export interface WhatsAppNotifyPayload {
+    toPhone: string;
+    title: string;
+    message: string;
+    type: string;
+    /** Approved Meta template name for this notification type, if configured. */
+    templateName?: string;
+    /** BCP-47 language code the template was approved in. Defaults to "en". */
+    templateLanguage?: string;
+    notificationId: string;
+    phoneNumberId: string;
+    accessToken: string;
+}
+export declare function runWhatsAppNotify(payload: WhatsAppNotifyPayload, ctx: JobContext): Promise<JobRunResult>;

package/dist/_internal/server/jobs/core/whatsappNotify.js

@@ -0,0 +1,82 @@
+/**
+ * Core: async WhatsApp notification dispatch (`whatsappNotify` job).
+ *
+ * `sendNotification()` (appkit/src/features/admin/actions/notification-actions.ts)
+ * no longer calls the Meta Cloud API synchronously in-request — it enqueues
+ * this job instead (CLAUDE.md Rule #6 async job primitive) and returns
+ * immediately. This runner does the actual send, with a bounded retry, and
+ * writes the outcome back onto `notifications/{notificationId}` so admins
+ * have visibility beyond the `jobs/{jobId}` doc itself.
+ *
+ * Retry note: `sendWhatsAppTemplateMessage`/`sendWhatsAppBusinessMessage`
+ * return a plain boolean (not a status code), so this runner cannot cleanly
+ * distinguish a transient 5xx from a terminal 4xx (bad token, unknown
+ * template) the way a status-code-aware client could. It retries any
+ * failure up to MAX_ATTEMPTS with a short backoff — an acceptable
+ * simplification since this runs off the critical path, well inside the
+ * Firebase Function's 300s budget, and a terminal error just burns two
+ * extra fast failures before giving up.
+ */
+import { normalizeError } from "../../../../errors/normalize";
+import { notificationRepository } from "../../../../features/admin/repository/notification.repository";
+import { sendWhatsAppTemplateMessage, sendWhatsAppBusinessMessage, } from "../../../../features/whatsapp-bot/helpers/whatsapp";
+const MAX_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 1500;
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function runWhatsAppNotify(payload, ctx) {
+    const { toPhone, title, message, templateName, templateLanguage, notificationId, phoneNumberId, accessToken } = payload;
+    let sent = false;
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS && !sent; attempt++) {
+        try {
+            sent = templateName
+                ? await sendWhatsAppTemplateMessage({
+                    toPhone,
+                    phoneNumberId,
+                    accessToken,
+                    templateName,
+                    languageCode: templateLanguage ?? "en",
+                    bodyParams: [title, message],
+                })
+                : await sendWhatsAppBusinessMessage({
+                    toPhone,
+                    phoneNumberId,
+                    accessToken,
+                    message: `*${title}*\n${message}`,
+                });
+            if (!sent)
+                lastError = "Meta WhatsApp API returned a non-OK response";
+        }
+        catch (err) {
+            void normalizeError(err);
+            lastError = err instanceof Error ? err.message : String(err);
+        }
+        if (!sent && attempt < MAX_ATTEMPTS) {
+            ctx.logger.warn("whatsappNotify: send attempt failed, retrying", { notificationId, attempt, error: lastError ?? "" });
+            await delay(RETRY_DELAY_MS * attempt);
+        }
+    }
+    if (!templateName) {
+        ctx.logger.warn("whatsappNotify: no approved template configured for this notification type — sent as free-form text, which Meta rejects outside the 24h customer-service window", { notificationId });
+    }
+    await notificationRepository
+        .update(notificationId, { whatsappStatus: sent ? "sent" : "failed" })
+        .catch((err) => {
+        void normalizeError(err);
+        ctx.logger.warn("whatsappNotify: failed to write back whatsappStatus onto notification doc", {
+            notificationId,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    });
+    if (!sent) {
+        throw new Error(lastError ?? "WhatsApp send failed after retries");
+    }
+    return {
+        summary: { total: 1, succeeded: 1, skipped: 0, failed: 0 },
+        succeeded: [notificationId],
+        skipped: [],
+        failed: [],
+    };
+}

package/dist/_internal/server/jobs/handlers/index.d.ts

@@ -28,6 +28,7 @@ export { paymentWindowTimeoutHandler } from "./paymentWindowTimeout";
 export { hardBanReinstatementHandler } from "./hardBanReinstatement";
 export { paymentReviewAutoApproveHandler } from "./paymentReviewAutoApprove";
 export { productStatsSyncHandler } from "./productStatsSync";
+export { revenueRollupHandler } from "./revenueRollup";
 export { positionsReconcileHandler } from "./positionsReconcile";
 export { payoutBatchHandler } from "./payoutBatch";
 export { weeklyPayoutEligibilityHandler } from "./weeklyPayoutEligibility";

package/dist/_internal/server/jobs/handlers/index.js

@@ -28,6 +28,7 @@ export { paymentWindowTimeoutHandler } from "./paymentWindowTimeout";
 export { hardBanReinstatementHandler } from "./hardBanReinstatement";
 export { paymentReviewAutoApproveHandler } from "./paymentReviewAutoApprove";
 export { productStatsSyncHandler } from "./productStatsSync";
+export { revenueRollupHandler } from "./revenueRollup";
 export { positionsReconcileHandler } from "./positionsReconcile";
 export { payoutBatchHandler } from "./payoutBatch";
 export { weeklyPayoutEligibilityHandler } from "./weeklyPayoutEligibility";

package/dist/_internal/server/jobs/handlers/revenueRollup.d.ts

@@ -0,0 +1,2 @@
+import type { ScheduleHandler } from "../runtime/types";
+export declare const revenueRollupHandler: ScheduleHandler;

package/dist/_internal/server/jobs/handlers/revenueRollup.js

@@ -0,0 +1,2 @@
+import { runRevenueRollup } from "../core/revenueRollup";
+export const revenueRollupHandler = runRevenueRollup;

package/dist/_internal/shared/features/auctions/config.d.ts

@@ -2,5 +2,5 @@ export declare const AUCTIONS_PAGE_SIZE = 20;
 export declare const AUCTIONS_ACTIVE_LIMIT = 50;
 export declare const AUCTIONS_SITEMAP_LIMIT = 5000;
 export declare const AUCTION_DEFAULT_EXTENSION_MINUTES = 5;
-export declare const AUCTION_MIN_BID_INCREMENT_PAISE = 100;
+export declare const AUCTION_MIN_BID_INCREMENT = 1;
 export declare const AUCTION_SNIPING_WINDOW_SECONDS = 300;

package/dist/_internal/shared/features/auctions/config.js

@@ -2,5 +2,5 @@ export const AUCTIONS_PAGE_SIZE = 20;
 export const AUCTIONS_ACTIVE_LIMIT = 50;
 export const AUCTIONS_SITEMAP_LIMIT = 5000;
 export const AUCTION_DEFAULT_EXTENSION_MINUTES = 5;
-export const AUCTION_MIN_BID_INCREMENT_PAISE = 100; // ₹1
+export const AUCTION_MIN_BID_INCREMENT = 1; // ₹1
 export const AUCTION_SNIPING_WINDOW_SECONDS = 300; // 5 minutes — triggers auto-extend

package/dist/_internal/shared/features/auctions/schema.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 export const placeBidSchema = z.object({
     auctionId: z.string().min(1),
-    amount: z.number().int().positive("Bid amount must be a positive integer (paise)"),
+    amount: z.number().positive("Bid amount must be a positive number"),
 });
 export const cancelBidSchema = z.object({
     bidId: z.string().min(1),

package/dist/_internal/shared/features/cart/schema.js

@@ -3,7 +3,7 @@ const cartItemBaseSchema = z.object({
     productId: z.string().min(1),
     productTitle: z.string(),
     productImage: z.string().default(""),
-    price: z.number().int().min(0),
+    price: z.number().min(0),
     currency: z.string().default("INR"),
     storeId: z.string(),
     storeName: z.string().default(""),
@@ -21,7 +21,7 @@ const cartItemBaseSchema = z.object({
     ]),
     isOffer: z.boolean().optional(),
     offerId: z.string().optional(),
-    lockedPrice: z.number().int().optional(),
+    lockedPrice: z.number().optional(),
 });
 export const addToCartSchema = cartItemBaseSchema;
 export const updateCartItemSchema = z.object({

package/dist/_internal/shared/features/checkout/config.d.ts

@@ -2,6 +2,13 @@ export declare const CHECKOUT_DEFAULT_COMMISSIONS: {
     readonly codDepositPercent: 10;
     readonly codHandlingFeeMin: 200;
     readonly codHandlingFeePercent: 10;
+    readonly whatsappNotifyFeeEnabled: false;
+    readonly whatsappNotifyFee: 10;
+    readonly giftWrapFeeEnabled: false;
+    readonly giftWrapFee: 49;
+    readonly shipmentProtectionFeeEnabled: false;
+    readonly shipmentProtectionFeePercent: 2;
+    readonly shipmentProtectionFeeMin: 30;
     readonly sellerShippingFixed: 50;
     readonly platformShippingPercent: 10;
     readonly platformShippingFixedMin: 50;