@mohasinac/appkit 3.0.4 → 3.1.0

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

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockSendNotification, mockRtdbPush, mockDecryptPii, } = vi.hoisted(() => ({
+    mockSendNotification: vi.fn().mockResolvedValue(undefined),
+    mockRtdbPush: vi.fn().mockResolvedValue(undefined),
+    mockDecryptPii: vi.fn((v) => v),
+}));
+vi.mock("../../../../../features/admin/actions/notification-actions", () => ({
+    sendNotification: mockSendNotification,
+}));
+vi.mock("../../../../../providers/db-firebase", () => ({
+    getAdminRealtimeDb: vi.fn(() => ({
+        ref: vi.fn(() => ({ push: mockRtdbPush })),
+    })),
+}));
+vi.mock("../../../../../security/index", () => ({
+    decryptPii: mockDecryptPii,
+}));
+vi.mock("../../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { handleOrderStatusChange } from "../onOrderStatusChange";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx() {
+    return {
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+function makeInput(beforeStatus, afterStatus, extraAfter = {}) {
+    return {
+        orderId: "order-1",
+        before: { status: beforeStatus },
+        after: {
+            status: afterStatus,
+            userId: "user-ravi",
+            userEmail: "ravi@example.com",
+            productTitle: "Pokemon Charizard",
+            trackingNumber: "TRK123",
+            ...extraAfter,
+        },
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockSendNotification.mockResolvedValue(undefined);
+    mockRtdbPush.mockResolvedValue(undefined);
+    mockDecryptPii.mockImplementation((v) => v);
+});
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("handleOrderStatusChange — early exits", () => {
+    it("returns immediately when before is null", async () => {
+        const ctx = makeCtx();
+        await handleOrderStatusChange({ orderId: "o1", before: null, after: null }, ctx);
+        expect(mockSendNotification).not.toHaveBeenCalled();
+    });
+    it("returns immediately when after is null", async () => {
+        const ctx = makeCtx();
+        await handleOrderStatusChange({ orderId: "o1", before: { status: "pending" }, after: null }, ctx);
+        expect(mockSendNotification).not.toHaveBeenCalled();
+    });
+    it("returns when status has not changed", async () => {
+        const ctx = makeCtx();
+        await handleOrderStatusChange(makeInput("confirmed", "confirmed"), ctx);
+        expect(mockSendNotification).not.toHaveBeenCalled();
+    });
+    it("logs and returns when new status has no handler config", async () => {
+        const ctx = makeCtx();
+        await handleOrderStatusChange(makeInput("pending", "returned"), ctx);
+        expect(mockSendNotification).not.toHaveBeenCalled();
+        expect(ctx.logger.info).toHaveBeenCalledWith(expect.stringMatching(/No handler for status transition/i), expect.any(Object));
+    });
+});
+describe("handleOrderStatusChange — confirmed", () => {
+    it("sends order_confirmed notification to buyer", async () => {
+        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userId: "user-ravi", type: "order_confirmed" }));
+    });
+    it("includes decrypted userEmail in notification payload", async () => {
+        mockDecryptPii.mockReturnValue("decrypted@example.com");
+        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ userEmail: "decrypted@example.com" }));
+    });
+    it("pushes to RTDB for real-time notification", async () => {
+        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
+        expect(mockRtdbPush).toHaveBeenCalledWith(expect.objectContaining({ type: "order_confirmed" }));
+    });
+});
+describe("handleOrderStatusChange — shipped", () => {
+    it("sends order_shipped notification with high priority", async () => {
+        await handleOrderStatusChange(makeInput("confirmed", "shipped"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "order_shipped", priority: "high" }));
+    });
+    it("notification message includes tracking number", async () => {
+        await handleOrderStatusChange(makeInput("confirmed", "shipped", { trackingNumber: "AWB123" }), makeCtx());
+        const notifCall = mockSendNotification.mock.calls[0][0];
+        expect(notifCall.message).toMatch(/AWB123/);
+    });
+});
+describe("handleOrderStatusChange — delivered", () => {
+    it("sends order_delivered notification", async () => {
+        await handleOrderStatusChange(makeInput("shipped", "delivered"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "order_delivered" }));
+    });
+    it("notification relatedId = orderId, relatedType = 'order'", async () => {
+        await handleOrderStatusChange(makeInput("shipped", "delivered"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ relatedId: "order-1", relatedType: "order" }));
+    });
+});
+describe("handleOrderStatusChange — cancelled", () => {
+    it("sends order_cancelled notification", async () => {
+        await handleOrderStatusChange(makeInput("pending", "cancelled"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalledWith(expect.objectContaining({ type: "order_cancelled" }));
+    });
+    it("cancelled message mentions the product title", async () => {
+        await handleOrderStatusChange(makeInput("pending", "cancelled", { productTitle: "Hot Wheels Redline" }), makeCtx());
+        const notifCall = mockSendNotification.mock.calls[0][0];
+        expect(notifCall.message).toMatch(/Hot Wheels Redline/);
+    });
+});
+describe("handleOrderStatusChange — RTDB failure is non-fatal", () => {
+    it("RTDB push failure → logs but does NOT re-throw", async () => {
+        mockRtdbPush.mockRejectedValue(new Error("RTDB down"));
+        const ctx = makeCtx();
+        await expect(handleOrderStatusChange(makeInput("pending", "confirmed"), ctx)).resolves.toBeUndefined();
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/Realtime DB/i), expect.any(Error));
+    });
+    it("Firestore notification still sent even when RTDB fails", async () => {
+        mockRtdbPush.mockRejectedValue(new Error("RTDB down"));
+        await handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx());
+        expect(mockSendNotification).toHaveBeenCalled();
+    });
+});
+describe("handleOrderStatusChange — error propagation", () => {
+    it("sendNotification failure → re-throws", async () => {
+        mockSendNotification.mockRejectedValue(new Error("Notification service down"));
+        await expect(handleOrderStatusChange(makeInput("pending", "confirmed"), makeCtx())).rejects.toThrow("Notification service down");
+    });
+    it("logs error context before re-throwing", async () => {
+        mockSendNotification.mockRejectedValue(new Error("Notification service down"));
+        const ctx = makeCtx();
+        try {
+            await handleOrderStatusChange(makeInput("pending", "confirmed"), ctx);
+        }
+        catch {
+            // expected
+        }
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.any(String), expect.any(Error), expect.objectContaining({ orderId: "order-1" }));
+    });
+});

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

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

package/dist/_internal/server/jobs/core/__tests__/onProductStockChange.test.js

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi } from "vitest";
+// onProductStockChange uses ctx.db directly, no repository imports needed.
+vi.mock("../../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { handleProductStockChange, isAvailable, syncBundlesForProduct, } from "../onProductStockChange";
+import { PRODUCT_FIELDS } from "../../../../../constants/field-names";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx(dbQuery) {
+    const mockQuery = dbQuery ?? vi.fn().mockReturnThis();
+    const queryChain = { where: vi.fn().mockReturnThis(), get: vi.fn() };
+    return {
+        db: {
+            collection: vi.fn().mockReturnValue(queryChain),
+        },
+        queryChain,
+        now: new Date(),
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+const PUBLISHED = PRODUCT_FIELDS.STATUS_VALUES.PUBLISHED;
+// ── isAvailable (pure function) ───────────────────────────────────────────────
+describe("isAvailable — pure function", () => {
+    it("null doc → false", () => {
+        expect(isAvailable(null)).toBe(false);
+    });
+    it("isSold=true → false", () => {
+        expect(isAvailable({ isSold: true, availableQuantity: 1, status: PUBLISHED })).toBe(false);
+    });
+    it("availableQuantity=0 → false", () => {
+        expect(isAvailable({ isSold: false, availableQuantity: 0, status: PUBLISHED })).toBe(false);
+    });
+    it("status != published → false", () => {
+        expect(isAvailable({ isSold: false, availableQuantity: 5, status: "draft" })).toBe(false);
+    });
+    it("status=published, qty>0, not sold → true", () => {
+        expect(isAvailable({ isSold: false, availableQuantity: 1, status: PUBLISHED })).toBe(true);
+    });
+    it("qty undefined (no quantity field) → true (quantity not tracked = always available)", () => {
+        // Intentional design: the check is `typeof qty === "number" && qty <= 0`.
+        // If qty is undefined, the guard is skipped → published product is available.
+        expect(isAvailable({ isSold: false, availableQuantity: undefined, status: PUBLISHED })).toBe(true);
+    });
+});
+// ── handleProductStockChange ──────────────────────────────────────────────────
+const INPUT_BASE = {
+    productId: "product-charizard",
+    isDelete: false,
+};
+function makeAvailableSnap() {
+    return { isSold: false, availableQuantity: 1, status: PUBLISHED };
+}
+function makeUnavailableSnap() {
+    return { isSold: false, availableQuantity: 0, status: PUBLISHED };
+}
+describe("handleProductStockChange — early exit: no state flip", () => {
+    it("skips when available → available (no flip)", async () => {
+        const ctx = makeCtx();
+        await handleProductStockChange({
+            ...INPUT_BASE,
+            before: makeAvailableSnap(),
+            after: makeAvailableSnap(),
+        }, ctx);
+        expect(ctx.db.collection).not.toHaveBeenCalled();
+    });
+    it("skips when unavailable → unavailable (no flip)", async () => {
+        const ctx = makeCtx();
+        await handleProductStockChange({
+            ...INPUT_BASE,
+            before: makeUnavailableSnap(),
+            after: makeUnavailableSnap(),
+        }, ctx);
+        expect(ctx.db.collection).not.toHaveBeenCalled();
+    });
+    it("processes when isDelete=true even if state appears unchanged", async () => {
+        const ctx = makeCtx();
+        ctx.db.collection = vi.fn().mockReturnValue({
+            where: vi.fn().mockReturnThis(),
+            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
+        });
+        await handleProductStockChange({
+            ...INPUT_BASE,
+            isDelete: true,
+            before: makeAvailableSnap(),
+            after: makeAvailableSnap(),
+        }, ctx);
+        expect(ctx.db.collection).toHaveBeenCalled();
+    });
+});
+describe("handleProductStockChange — state flip triggers sync", () => {
+    it("available → unavailable triggers sync", async () => {
+        const ctx = makeCtx();
+        ctx.db.collection = vi.fn().mockReturnValue({
+            where: vi.fn().mockReturnThis(),
+            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
+        });
+        await handleProductStockChange({
+            ...INPUT_BASE,
+            before: makeAvailableSnap(),
+            after: makeUnavailableSnap(),
+        }, ctx);
+        expect(ctx.db.collection).toHaveBeenCalled();
+    });
+    it("unavailable → available triggers sync", async () => {
+        const ctx = makeCtx();
+        ctx.db.collection = vi.fn().mockReturnValue({
+            where: vi.fn().mockReturnThis(),
+            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
+        });
+        await handleProductStockChange({
+            ...INPUT_BASE,
+            before: makeUnavailableSnap(),
+            after: makeAvailableSnap(),
+        }, ctx);
+        expect(ctx.db.collection).toHaveBeenCalled();
+    });
+    it("logs synced bundles and groups count", async () => {
+        const ctx = makeCtx();
+        ctx.db.collection = vi.fn().mockReturnValue({
+            where: vi.fn().mockReturnThis(),
+            get: vi.fn().mockResolvedValue({ docs: [], size: 0 }),
+        });
+        await handleProductStockChange({
+            ...INPUT_BASE,
+            before: makeAvailableSnap(),
+            after: makeUnavailableSnap(),
+        }, ctx);
+        expect(ctx.logger.info).toHaveBeenCalledWith("onProductStockChange synced", expect.objectContaining({ productId: "product-charizard" }));
+    });
+    it("sync failure is non-fatal — logs error but does not throw", async () => {
+        const ctx = makeCtx();
+        ctx.db.collection = vi.fn().mockImplementation(() => {
+            throw new Error("Firestore unavailable");
+        });
+        await expect(handleProductStockChange({
+            ...INPUT_BASE,
+            before: makeAvailableSnap(),
+            after: makeUnavailableSnap(),
+        }, ctx)).resolves.toBeUndefined();
+        expect(ctx.logger.error).toHaveBeenCalled();
+    });
+});
+describe("syncBundlesForProduct — bundle recompute", () => {
+    it("does nothing when no bundles reference the product", async () => {
+        const ctx = makeCtx();
+        const mockQuery = { where: vi.fn().mockReturnThis(), get: vi.fn().mockResolvedValue({ docs: [], size: 0 }) };
+        ctx.db.collection = vi.fn().mockReturnValue(mockQuery);
+        const updated = await syncBundlesForProduct("product-x", ctx);
+        expect(updated).toBe(0);
+    });
+    it("updates bundle when stockStatus changes", async () => {
+        // Bundle has 1 product: "product-x" (now unavailable)
+        const bundleRef = { update: vi.fn().mockResolvedValue(undefined) };
+        const bundleDoc = {
+            ref: bundleRef,
+            data: () => ({
+                bundleProductIds: ["product-x"],
+                bundleStockStatus: "in_stock", // currently in_stock...
+            }),
+        };
+        const memberSnap = {
+            docs: [{ data: () => ({ isSold: false, availableQuantity: 0, status: PUBLISHED }) }],
+            size: 1,
+        };
+        const ctx = makeCtx();
+        let callIdx = 0;
+        ctx.db.collection = vi.fn().mockReturnValue({
+            where: vi.fn().mockReturnThis(),
+            get: vi.fn().mockImplementation(async () => {
+                callIdx++;
+                // First call = bundles query; subsequent calls = member product queries
+                if (callIdx === 1)
+                    return { docs: [bundleDoc], size: 1 };
+                return memberSnap;
+            }),
+        });
+        const updated = await syncBundlesForProduct("product-x", ctx);
+        expect(updated).toBe(1);
+        expect(bundleRef.update).toHaveBeenCalledWith(expect.objectContaining({ bundleStockStatus: "out_of_stock" }));
+    });
+    it("does NOT update bundle when stockStatus has not changed", async () => {
+        const bundleRef = { update: vi.fn().mockResolvedValue(undefined) };
+        const bundleDoc = {
+            ref: bundleRef,
+            data: () => ({
+                bundleProductIds: ["product-x"],
+                bundleStockStatus: "in_stock", // already in_stock
+            }),
+        };
+        // Member is available → status stays in_stock → no update needed
+        const memberSnap = {
+            docs: [{ data: () => ({ isSold: false, availableQuantity: 5, status: PUBLISHED }) }],
+            size: 1,
+        };
+        const ctx = makeCtx();
+        let callIdx = 0;
+        ctx.db.collection = vi.fn().mockReturnValue({
+            where: vi.fn().mockReturnThis(),
+            get: vi.fn().mockImplementation(async () => {
+                callIdx++;
+                if (callIdx === 1)
+                    return { docs: [bundleDoc], size: 1 };
+                return memberSnap;
+            }),
+        });
+        const updated = await syncBundlesForProduct("product-x", ctx);
+        expect(updated).toBe(0);
+        expect(bundleRef.update).not.toHaveBeenCalled();
+    });
+});

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

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

package/dist/_internal/server/jobs/core/__tests__/onReviewWrite.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+const { mockGetRatingAggregate, mockGetRatingAggregateByStore, mockProductUpdate, mockUpdateReviewStats, } = vi.hoisted(() => ({
+    mockGetRatingAggregate: vi.fn(),
+    mockGetRatingAggregateByStore: vi.fn(),
+    mockProductUpdate: vi.fn().mockResolvedValue(undefined),
+    mockUpdateReviewStats: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("../../../../../repositories", () => ({
+    reviewRepository: {
+        getApprovedRatingAggregate: mockGetRatingAggregate,
+        getApprovedRatingAggregateByStore: mockGetRatingAggregateByStore,
+    },
+    storeRepository: {
+        updateReviewStats: mockUpdateReviewStats,
+    },
+}));
+vi.mock("../../../../../features/reviews/schemas/firestore", () => ({
+    ReviewStatusValues: {
+        APPROVED: "approved",
+        PENDING: "pending",
+        REJECTED: "rejected",
+    },
+}));
+vi.mock("../../../../../features/products/schemas/firestore", () => ({
+    PRODUCT_COLLECTION: "products",
+}));
+import { handleReviewWrite } from "../onReviewWrite";
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function makeCtx() {
+    return {
+        db: {
+            collection: vi.fn().mockReturnValue({
+                doc: vi.fn().mockReturnValue({
+                    update: mockProductUpdate,
+                }),
+            }),
+        },
+        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    };
+}
+function makeReviewData(overrides = {}) {
+    return {
+        productId: "product-charizard",
+        storeId: "store-A",
+        buyerId: "user-ravi",
+        rating: 5,
+        status: "approved",
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockProductUpdate.mockResolvedValue(undefined);
+    mockUpdateReviewStats.mockResolvedValue(undefined);
+    mockGetRatingAggregate.mockResolvedValue({ count: 10, avgRating: 4.5 });
+    mockGetRatingAggregateByStore.mockResolvedValue({ count: 5, avgRating: 4.2 });
+});
+// ── Tests ────────────────────────────────────────────────────────────────────
+describe("handleReviewWrite — early exits", () => {
+    it("skips if neither before nor after is approved", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "pending" }),
+            after: makeReviewData({ status: "rejected" }),
+        }, ctx);
+        expect(mockGetRatingAggregate).not.toHaveBeenCalled();
+    });
+    it("skips if both before and after are non-approved status", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "rejected" }),
+            after: makeReviewData({ status: "pending" }),
+        }, ctx);
+        expect(mockProductUpdate).not.toHaveBeenCalled();
+    });
+    it("skips if no data (both before and after are null)", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({ reviewId: "r1", before: null, after: null }, ctx);
+        expect(mockGetRatingAggregate).not.toHaveBeenCalled();
+    });
+    it("logs and skips if review has no productId", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: null,
+            after: makeReviewData({ status: "approved", productId: undefined }),
+        }, ctx);
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/no productId/i), null, expect.any(Object));
+        expect(mockGetRatingAggregate).not.toHaveBeenCalled();
+    });
+});
+describe("handleReviewWrite — review approved (new approval)", () => {
+    it("recalculates rating aggregate for the product", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "pending" }),
+            after: makeReviewData({ status: "approved" }),
+        }, ctx);
+        expect(mockGetRatingAggregate).toHaveBeenCalledWith("product-charizard");
+    });
+    it("updates product avgRating and reviewCount", async () => {
+        mockGetRatingAggregate.mockResolvedValue({ count: 7, avgRating: 4.2 });
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "pending" }),
+            after: makeReviewData({ status: "approved" }),
+        }, ctx);
+        expect(mockProductUpdate).toHaveBeenCalledWith(expect.objectContaining({ avgRating: 4.2, reviewCount: 7 }));
+    });
+    it("updates store review stats when storeId is present", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "pending" }),
+            after: makeReviewData({ status: "approved", storeId: "store-A" }),
+        }, ctx);
+        expect(mockGetRatingAggregateByStore).toHaveBeenCalledWith("store-A");
+        expect(mockUpdateReviewStats).toHaveBeenCalledWith("store-A", 5, 4.2);
+    });
+    it("skips store stats update when storeId is absent", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "pending" }),
+            after: makeReviewData({ status: "approved", storeId: undefined }),
+        }, ctx);
+        expect(mockGetRatingAggregateByStore).not.toHaveBeenCalled();
+        expect(mockUpdateReviewStats).not.toHaveBeenCalled();
+    });
+});
+describe("handleReviewWrite — review rejected (was approved)", () => {
+    it("recalculates rating when a review transitions from approved to rejected", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "approved" }),
+            after: makeReviewData({ status: "rejected" }),
+        }, ctx);
+        expect(mockGetRatingAggregate).toHaveBeenCalled();
+        expect(mockProductUpdate).toHaveBeenCalled();
+    });
+    it("uses afterData for productId when available", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "approved", productId: "old-product" }),
+            after: makeReviewData({ status: "rejected", productId: "product-charizard" }),
+        }, ctx);
+        expect(mockGetRatingAggregate).toHaveBeenCalledWith("product-charizard");
+    });
+    it("falls back to beforeData for productId when after is null (delete)", async () => {
+        const ctx = makeCtx();
+        await handleReviewWrite({
+            reviewId: "r1",
+            before: makeReviewData({ status: "approved", productId: "product-abc" }),
+            after: null,
+        }, ctx);
+        expect(mockGetRatingAggregate).toHaveBeenCalledWith("product-abc");
+    });
+});
+describe("handleReviewWrite — error propagation", () => {
+    it("aggregate calculation failure → re-throws", async () => {
+        mockGetRatingAggregate.mockRejectedValue(new Error("Firestore error"));
+        const ctx = makeCtx();
+        await expect(handleReviewWrite({
+            reviewId: "r1",
+            before: null,
+            after: makeReviewData({ status: "approved" }),
+        }, ctx)).rejects.toThrow("Firestore error");
+    });
+    it("logs error before re-throwing", async () => {
+        mockGetRatingAggregate.mockRejectedValue(new Error("Firestore error"));
+        const ctx = makeCtx();
+        try {
+            await handleReviewWrite({
+                reviewId: "r1",
+                before: null,
+                after: makeReviewData({ status: "approved" }),
+            }, ctx);
+        }
+        catch {
+            // expected
+        }
+        expect(ctx.logger.error).toHaveBeenCalledWith(expect.stringMatching(/rating stats/i), expect.any(Error), expect.any(Object));
+    });
+});

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

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