@mohasinac/appkit 3.8.2 → 3.9.0

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

@@ -1,252 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-// No repository mocks needed — function uses ctx.db directly.
-import { runTriggerEventRaffle } from "../triggerEventRaffle";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeCtx(dbOverrides = {}) {
-    return {
-        db: buildMockDb(dbOverrides),
-        now: new Date("2026-01-01T00:00:00Z"),
-        env: vi.fn().mockReturnValue(""),
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-}
-/**
- * Builds a mock Firestore db that:
- *  - eventSnap: resolved by the 'events' collection path
- *  - entriesSnap: resolved by the 'eventEntries' collection path
- */
-function buildMockDb(overrides = {}) {
-    const { eventExists = true, eventData = {}, entriesDocs = [], updateFn = vi.fn().mockResolvedValue(undefined), } = overrides;
-    const mockUpdate = updateFn;
-    // Chain for event: db.collection("events").doc(id).get()
-    const eventSnap = { exists: eventExists, data: () => eventData };
-    const eventDocRef = { get: vi.fn().mockResolvedValue(eventSnap), update: mockUpdate };
-    const eventsCollection = { doc: vi.fn().mockReturnValue(eventDocRef) };
-    // Chain for entries: db.collection("eventEntries").where(...).where(...).get()
-    const entriesSnap = {
-        docs: entriesDocs,
-        size: entriesDocs.length,
-    };
-    const entriesQuery = {
-        where: vi.fn().mockReturnThis(),
-        get: vi.fn().mockResolvedValue(entriesSnap),
-    };
-    const entriesCollection = { where: vi.fn().mockReturnValue(entriesQuery) };
-    const db = {
-        collection: vi.fn((name) => {
-            if (name === "events")
-                return eventsCollection;
-            if (name === "eventEntries")
-                return entriesCollection;
-            return eventsCollection;
-        }),
-        mockUpdate, // expose for assertions
-    };
-    return db;
-}
-function makeEntry(overrides = {}) {
-    const { id = "entry-1", userId = "user-ravi", displayName = "Ravi Kumar", points = 0, createdAt = new Date() } = overrides;
-    return {
-        id,
-        data: () => ({ userId, userDisplayName: displayName, points, createdAt }),
-    };
-}
-const INPUT_BASE = { eventId: "event-summer-raffle" };
-// ── Tests ────────────────────────────────────────────────────────────────────
-describe("runTriggerEventRaffle — event not found", () => {
-    it("returns reason=event_not_found when event does not exist", async () => {
-        const ctx = makeCtx({ eventExists: false });
-        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(result.reason).toBe("event_not_found");
-        expect(result.raffleEntryCount).toBe(0);
-    });
-    it("does NOT update eventRef when event not found", async () => {
-        const ctx = makeCtx({ eventExists: false });
-        await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(ctx.db.mockUpdate).not.toHaveBeenCalled();
-    });
-});
-describe("runTriggerEventRaffle — already triggered (idempotency)", () => {
-    it("returns alreadyTriggered=true when winner already set", async () => {
-        const ctx = makeCtx({ eventData: { raffleWinnerUserId: "user-already-won" } });
-        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(result.alreadyTriggered).toBe(true);
-        expect(result.raffleWinnerUserId).toBe("user-already-won");
-    });
-    it("does NOT query entries or update event when already triggered", async () => {
-        const ctx = makeCtx({ eventData: { raffleWinnerUserId: "user-already-won" } });
-        await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(ctx.db.mockUpdate).not.toHaveBeenCalled();
-    });
-});
-describe("runTriggerEventRaffle — no eligible entries", () => {
-    it("returns reason=no_eligible_entries when no CONFIRMED entries exist", async () => {
-        const ctx = makeCtx({ entriesDocs: [] });
-        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(result.reason).toBe("no_eligible_entries");
-        expect(result.raffleEntryCount).toBe(0);
-    });
-    it("does NOT update event when no entries", async () => {
-        const ctx = makeCtx({ entriesDocs: [] });
-        await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(ctx.db.mockUpdate).not.toHaveBeenCalled();
-    });
-});
-describe("runTriggerEventRaffle — open_raffle (default)", () => {
-    it("all confirmed entries are in the pool", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-1" }),
-            makeEntry({ id: "e2", userId: "user-2" }),
-            makeEntry({ id: "e3", userId: "user-3" }),
-        ];
-        const ctx = makeCtx({ eventData: { raffleType: "open_raffle" }, entriesDocs: entries });
-        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(["user-1", "user-2", "user-3"]).toContain(result.raffleWinnerUserId);
-    });
-    it("winner fields written back to event doc", async () => {
-        const updateFn = vi.fn().mockResolvedValue(undefined);
-        const entries = [makeEntry({ id: "e1", userId: "user-ravi", displayName: "Ravi" })];
-        const ctx = makeCtx({ entriesDocs: entries, updateFn });
-        await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(updateFn).toHaveBeenCalledWith(expect.objectContaining({
-            raffleWinnerUserId: "user-ravi",
-            raffleWinnerDisplayName: "Ravi",
-            raffleWinnerEntryId: "e1",
-            raffleEntryCount: 1,
-        }));
-    });
-    it("raffleTriggeredAt = ctx.now", async () => {
-        const updateFn = vi.fn().mockResolvedValue(undefined);
-        const now = new Date("2026-03-15T10:00:00Z");
-        const entries = [makeEntry({ id: "e1" })];
-        const ctx = makeCtx({ entriesDocs: entries, updateFn });
-        ctx.now = now;
-        await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(updateFn).toHaveBeenCalledWith(expect.objectContaining({ raffleTriggeredAt: now }));
-    });
-    it("raffleEntryCount = total entries (not pool size)", async () => {
-        const updateFn = vi.fn().mockResolvedValue(undefined);
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-1" }),
-            makeEntry({ id: "e2", userId: "user-2" }),
-        ];
-        const ctx = makeCtx({ entriesDocs: entries, updateFn });
-        await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "open_raffle" }, ctx);
-        expect(updateFn).toHaveBeenCalledWith(expect.objectContaining({ raffleEntryCount: 2 }));
-    });
-    it("returns correct winner in result object", async () => {
-        const entries = [makeEntry({ id: "e1", userId: "user-only", displayName: "Only User" })];
-        const ctx = makeCtx({ entriesDocs: entries });
-        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-only");
-        expect(result.raffleWinnerDisplayName).toBe("Only User");
-        expect(result.raffleEntryCount).toBe(1);
-    });
-});
-describe("runTriggerEventRaffle — top_n_scorers", () => {
-    it("pool limited to top N by points descending", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-low", points: 10 }),
-            makeEntry({ id: "e2", userId: "user-high", points: 100 }),
-            makeEntry({ id: "e3", userId: "user-mid", points: 50 }),
-        ];
-        const ctx = makeCtx({ entriesDocs: entries });
-        // topN=1 means only the highest scorer can win
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 1 }, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-high");
-    });
-    it("topN=2: winner is either top-1 or top-2 scorer, NOT bottom scorer", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-bottom", points: 1 }),
-            makeEntry({ id: "e2", userId: "user-top", points: 100 }),
-            makeEntry({ id: "e3", userId: "user-second", points: 50 }),
-        ];
-        const ctx = makeCtx({ entriesDocs: entries });
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 2 }, ctx);
-        expect(["user-top", "user-second"]).toContain(result.raffleWinnerUserId);
-        expect(result.raffleWinnerUserId).not.toBe("user-bottom");
-    });
-    it("topN=0 → entire pool used (topN disabled)", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-1", points: 10 }),
-            makeEntry({ id: "e2", userId: "user-2", points: 20 }),
-        ];
-        const ctx = makeCtx({ entriesDocs: entries });
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 0 }, ctx);
-        expect(["user-1", "user-2"]).toContain(result.raffleWinnerUserId);
-    });
-    it("reads raffleTopN from event when topN not in input", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-low", points: 5 }),
-            makeEntry({ id: "e2", userId: "user-high", points: 999 }),
-        ];
-        const ctx = makeCtx({
-            eventData: { raffleType: "top_n_scorers", raffleTopN: 1 },
-            entriesDocs: entries,
-        });
-        const result = await runTriggerEventRaffle(INPUT_BASE, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-high");
-    });
-});
-describe("runTriggerEventRaffle — top_n_participants", () => {
-    it("pool limited to first N by createdAt ascending", async () => {
-        const t1 = new Date("2026-01-01");
-        const t2 = new Date("2026-01-02");
-        const t3 = new Date("2026-01-03");
-        const entries = [
-            makeEntry({ id: "e3", userId: "user-last", createdAt: t3 }),
-            makeEntry({ id: "e1", userId: "user-first", createdAt: t1 }),
-            makeEntry({ id: "e2", userId: "user-second", createdAt: t2 }),
-        ];
-        const ctx = makeCtx({ entriesDocs: entries });
-        // topN=1 means only the earliest registrant wins
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_participants", topN: 1 }, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-first");
-    });
-    it("handles Firestore Timestamp-like createdAt objects (via toDate)", async () => {
-        const entries = [
-            makeEntry({
-                id: "e1",
-                userId: "user-a",
-                createdAt: { toDate: () => new Date("2026-01-01") },
-            }),
-            makeEntry({
-                id: "e2",
-                userId: "user-b",
-                createdAt: { toDate: () => new Date("2026-01-02") },
-            }),
-        ];
-        const ctx = makeCtx({ entriesDocs: entries });
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_participants", topN: 1 }, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-a");
-    });
-});
-describe("runTriggerEventRaffle — input override precedence", () => {
-    it("input.raffleType overrides event.raffleType", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-low", points: 1 }),
-            makeEntry({ id: "e2", userId: "user-high", points: 999 }),
-        ];
-        // Event says open_raffle, but input says top_n_scorers topN=1
-        const ctx = makeCtx({
-            eventData: { raffleType: "open_raffle" },
-            entriesDocs: entries,
-        });
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 1 }, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-high");
-    });
-    it("input.topN overrides event.raffleTopN", async () => {
-        const entries = [
-            makeEntry({ id: "e1", userId: "user-low", points: 5 }),
-            makeEntry({ id: "e2", userId: "user-high", points: 100 }),
-            makeEntry({ id: "e3", userId: "user-mid", points: 50 }),
-        ];
-        // Event says topN=3 (all), but input says topN=1 (only highest)
-        const ctx = makeCtx({
-            eventData: { raffleType: "top_n_scorers", raffleTopN: 3 },
-            entriesDocs: entries,
-        });
-        const result = await runTriggerEventRaffle({ ...INPUT_BASE, raffleType: "top_n_scorers", topN: 1 }, ctx);
-        expect(result.raffleWinnerUserId).toBe("user-high");
-    });
-});

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

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

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

@@ -1,129 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-const { mockRecord, mockMapToHttpError } = vi.hoisted(() => ({
-    mockRecord: vi.fn().mockResolvedValue(undefined),
-    mockMapToHttpError: vi.fn().mockReturnValue({ code: 500, message: "Internal error" }),
-}));
-vi.mock("../../../../../features/server-errors/repository/server-errors.repository", () => ({
-    serverErrorsRepository: vi.fn(() => ({ record: mockRecord })),
-}));
-vi.mock("../../../../../errors/error-mapping", () => ({
-    mapToHttpError: mockMapToHttpError,
-}));
-import { wrapScheduleHandler, wrapTriggerHandler, wrapCallableHandler, wrapJobHandler, } from "../wrapJobHandler";
-function makeCtx() {
-    return {
-        db: {},
-        now: new Date("2026-01-01"),
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockRecord.mockResolvedValue(undefined);
-    mockMapToHttpError.mockReturnValue({ code: 500, message: "Internal error" });
-});
-// ── wrapScheduleHandler ──────────────────────────────────────────────────────
-describe("wrapScheduleHandler", () => {
-    it("returns handler result when handler succeeds", async () => {
-        const handler = vi.fn().mockResolvedValue(undefined);
-        const wrapped = wrapScheduleHandler("my-job", handler);
-        await expect(wrapped(makeCtx())).resolves.toBeUndefined();
-    });
-    it("persists error to serverErrors when handler throws", async () => {
-        const handler = vi.fn().mockRejectedValue(new Error("job failed"));
-        const wrapped = wrapScheduleHandler("my-job", handler);
-        try {
-            await wrapped(makeCtx());
-        }
-        catch { /* expected */ }
-        expect(mockRecord).toHaveBeenCalledWith(expect.objectContaining({ source: "function", route: "my-job" }));
-    });
-    it("re-throws the original error after persisting", async () => {
-        const err = new Error("job failed");
-        const handler = vi.fn().mockRejectedValue(err);
-        const wrapped = wrapScheduleHandler("my-job", handler);
-        await expect(wrapped(makeCtx())).rejects.toThrow("job failed");
-    });
-    it("persist failure does NOT prevent re-throw", async () => {
-        const err = new Error("job failed");
-        mockRecord.mockRejectedValue(new Error("DB write failed"));
-        const handler = vi.fn().mockRejectedValue(err);
-        const wrapped = wrapScheduleHandler("my-job", handler);
-        await expect(wrapped(makeCtx())).rejects.toThrow("job failed");
-    });
-    it("calls mapToHttpError to normalise the error", async () => {
-        const err = new Error("Something broke");
-        const handler = vi.fn().mockRejectedValue(err);
-        const wrapped = wrapScheduleHandler("my-job", handler);
-        try {
-            await wrapped(makeCtx());
-        }
-        catch { /* expected */ }
-        expect(mockMapToHttpError).toHaveBeenCalledWith(err);
-    });
-    it("requestId includes handler name", async () => {
-        const handler = vi.fn().mockRejectedValue(new Error("oops"));
-        const wrapped = wrapScheduleHandler("audit-run", handler);
-        try {
-            await wrapped(makeCtx());
-        }
-        catch { /* expected */ }
-        const call = mockRecord.mock.calls[0][0];
-        expect(call.requestId).toMatch(/audit-run/);
-    });
-});
-// ── wrapTriggerHandler ───────────────────────────────────────────────────────
-describe("wrapTriggerHandler", () => {
-    const mockEvent = { path: "test/doc1", params: {}, before: null, after: {} };
-    it("returns handler result when handler succeeds", async () => {
-        const handler = vi.fn().mockResolvedValue(undefined);
-        const wrapped = wrapTriggerHandler("trigger-fn", handler);
-        await expect(wrapped(mockEvent, makeCtx())).resolves.toBeUndefined();
-    });
-    it("persists error and re-throws when handler throws", async () => {
-        const err = new Error("trigger failed");
-        const handler = vi.fn().mockRejectedValue(err);
-        const wrapped = wrapTriggerHandler("trigger-fn", handler);
-        await expect(wrapped(mockEvent, makeCtx())).rejects.toThrow("trigger failed");
-        expect(mockRecord).toHaveBeenCalled();
-    });
-});
-// ── wrapCallableHandler ──────────────────────────────────────────────────────
-describe("wrapCallableHandler", () => {
-    it("returns handler result when handler succeeds", async () => {
-        const handler = vi.fn().mockResolvedValue({ result: "ok" });
-        const wrapped = wrapCallableHandler("callable-fn", handler);
-        await expect(wrapped({}, makeCtx())).resolves.toEqual({ result: "ok" });
-    });
-    it("persists error and re-throws when handler throws", async () => {
-        const handler = vi.fn().mockRejectedValue(new Error("callable failed"));
-        const wrapped = wrapCallableHandler("callable-fn", handler);
-        await expect(wrapped({}, makeCtx())).rejects.toThrow("callable failed");
-        expect(mockRecord).toHaveBeenCalled();
-    });
-});
-// ── wrapJobHandler ───────────────────────────────────────────────────────────
-describe("wrapJobHandler", () => {
-    it("returns handler result for a generic handler", async () => {
-        const handler = vi.fn().mockResolvedValue(42);
-        const wrapped = wrapJobHandler("generic-fn", handler);
-        await expect(wrapped()).resolves.toBe(42);
-    });
-    it("persists error with handler name and re-throws", async () => {
-        const handler = vi.fn().mockRejectedValue(new Error("generic failed"));
-        const wrapped = wrapJobHandler("generic-fn", handler);
-        await expect(wrapped()).rejects.toThrow("generic failed");
-        expect(mockRecord).toHaveBeenCalledWith(expect.objectContaining({ route: "generic-fn", source: "function" }));
-    });
-    it("extracts JobContext from last arg if it has .now", async () => {
-        const now = new Date("2026-06-15T12:00:00Z");
-        const handler = vi.fn().mockRejectedValue(new Error("err"));
-        const wrapped = wrapJobHandler("fn-with-ctx", handler);
-        try {
-            await wrapped({ now });
-        }
-        catch { /* expected */ }
-        const call = mockRecord.mock.calls[0][0];
-        expect(call.occurredAt).toBe(now.getTime());
-    });
-});

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

@@ -1,15 +0,0 @@
-import type { JobContext } from "../runtime/types";
-import type { CatalogueItemDocument } from "../../../../features/catalogue/schemas/firestore";
-export interface CatalogueApprovalEvent {
-    itemId: string;
-    before: CatalogueItemDocument;
-    after: CatalogueItemDocument;
-}
-/**
- * Fires when a catalogue item's `listingStatus` transitions to
- * "pending_admin_approval" (a buyer's "Request to sell"). Notifies every
- * admin so the approvals queue doesn't go unnoticed. Kept out of the
- * synchronous submit action per Rule #6 — the buyer-facing request stays
- * fast regardless of how many admins there are to fan out to.
- */
-export declare function handleCatalogueSubmittedForApproval(event: CatalogueApprovalEvent, ctx: JobContext): Promise<void>;

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

@@ -1,38 +0,0 @@
-import { userRepository } from "../../../../features/auth/repository/user.repository";
-import { sendNotification } from "../../../../features/admin/actions/notification-actions";
-import { normalizeError } from "../../../../errors/normalize";
-/**
- * Fires when a catalogue item's `listingStatus` transitions to
- * "pending_admin_approval" (a buyer's "Request to sell"). Notifies every
- * admin so the approvals queue doesn't go unnoticed. Kept out of the
- * synchronous submit action per Rule #6 — the buyer-facing request stays
- * fast regardless of how many admins there are to fan out to.
- */
-export async function handleCatalogueSubmittedForApproval(event, ctx) {
-    const becamePending = event.before.listingStatus !== "pending_admin_approval" &&
-        event.after.listingStatus === "pending_admin_approval";
-    if (!becamePending)
-        return;
-    const admins = await userRepository.findByRole("admin");
-    for (const admin of admins) {
-        try {
-            await sendNotification({
-                userId: admin.uid,
-                type: "system",
-                priority: "normal",
-                title: "New catalogue listing request",
-                message: `"${event.after.title}" was submitted for approval to list under LetItRip Official.`,
-                actionUrl: "/admin/catalogue-approvals",
-                actionLabel: "Review request",
-                relatedId: event.itemId,
-            });
-        }
-        catch (err) {
-            void normalizeError(err);
-            ctx.logger.error("onCatalogueSubmittedForApproval: failed to notify admin", {
-                itemId: event.itemId,
-                adminUid: admin.uid,
-            });
-        }
-    }
-}

package/dist/_internal/server/providers/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Public surface for the provider resolver + mocks.
- *
- * Real provider implementations remain in `appkit/src/providers/{payment-razorpay,payment-manual,shipping-manual}/`
- * because they are independently consumable per-package. This barrel only
- * exposes the resolver entry points and the in-process mock implementations
- * Track H requires. Shipping has no mock — the manual shipping provider
- * makes no external API calls, so there's nothing to mock.
- */
-export { resolvePaymentProvider, type PaymentResolutionFactories, type ProviderResolutionContext, } from "./resolve";
-export { MockRazorpayProvider, type MockWebhookEvent, type MockWebhookPayload, type WebhookSink, } from "./payment/razorpay-mock";

package/dist/_internal/server/providers/index.js

@@ -1,11 +0,0 @@
-/**
- * Public surface for the provider resolver + mocks.
- *
- * Real provider implementations remain in `appkit/src/providers/{payment-razorpay,payment-manual,shipping-manual}/`
- * because they are independently consumable per-package. This barrel only
- * exposes the resolver entry points and the in-process mock implementations
- * Track H requires. Shipping has no mock — the manual shipping provider
- * makes no external API calls, so there's nothing to mock.
- */
-export { resolvePaymentProvider, } from "./resolve";
-export { MockRazorpayProvider, } from "./payment/razorpay-mock";

package/dist/_internal/server/providers/payment/razorpay-mock.d.ts

@@ -1,52 +0,0 @@
-/**
- * `MockRazorpayProvider` — in-process mock implementing `IPaymentProvider`.
- *
- * Replaces the orphaned `/api/dev/mock-razorpay/**` HTTP routes (deleted in
- * Track H). The mock behaviour is preserved bit-for-bit so checkout flows
- * exercise identical wire shapes:
- *
- *   - Order IDs prefix `order_mock_`, payment IDs `pay_mock_`, refund IDs
- *     `rfnd_mock_` — matches the previous route output exactly.
- *   - Webhook signatures use HMAC-SHA256 with the deterministic
- *     `MOCK_WEBHOOK_SECRET` so `verifyWebhook(raw, sig)` returns true for
- *     any signature the mock itself produced.
- *   - In-memory `Map<orderId, PaymentOrder>` survives per process. State is
- *     intentionally not persisted — tests reset between runs by recreating
- *     the provider instance.
- *
- * Mocks-only operations:
- *   - `emitWebhook(event)` synchronously fires a webhook payload through a
- *     consumer-supplied callback so end-to-end tests can drive a
- *     payment.captured / payment.failed / order.paid event without leaving
- *     the process. Registered via `setWebhookSink(fn)`.
- */
-import { IPaymentProvider } from "../../../../contracts";
-import type { PaymentCapture, PaymentOrder, Refund } from "../../../../contracts";
-import type { JsonValue } from "../../../../schemas/types";
-export type MockWebhookEvent = "payment.captured" | "payment.failed" | "order.paid";
-export interface MockWebhookPayload {
-    readonly event: MockWebhookEvent;
-    readonly orderId: string;
-    readonly paymentId: string;
-    readonly amount: number;
-    readonly currency: string;
-}
-export type WebhookSink = (rawBody: string, signature: string, payload: MockWebhookPayload) => Promise<void> | void;
-export declare class MockRazorpayProvider extends IPaymentProvider {
-    readonly name: "razorpay-mock";
-    private readonly orders;
-    private readonly captures;
-    private webhookSink;
-    setWebhookSink(sink: WebhookSink | null): void;
-    createOrder(amount: number, currency: string, metadata?: Record<string, JsonValue>): Promise<PaymentOrder>;
-    verifyWebhook(payload: string, signature: string): boolean;
-    capturePayment(orderId: string): Promise<PaymentCapture>;
-    refund(paymentId: string, amount?: number): Promise<Refund>;
-    getOrder(orderId: string): Promise<PaymentOrder>;
-    /**
-     * Mocks-only — fire a webhook event through the consumer-registered sink.
-     * Used by `/api/admin/dev/emit-payment-webhook` to drive end-to-end test
-     * flows. Throws if no sink is registered.
-     */
-    emitWebhook(payload: MockWebhookPayload): Promise<void>;
-}

package/dist/_internal/server/providers/payment/razorpay-mock.js

@@ -1,118 +0,0 @@
-/**
- * `MockRazorpayProvider` — in-process mock implementing `IPaymentProvider`.
- *
- * Replaces the orphaned `/api/dev/mock-razorpay/**` HTTP routes (deleted in
- * Track H). The mock behaviour is preserved bit-for-bit so checkout flows
- * exercise identical wire shapes:
- *
- *   - Order IDs prefix `order_mock_`, payment IDs `pay_mock_`, refund IDs
- *     `rfnd_mock_` — matches the previous route output exactly.
- *   - Webhook signatures use HMAC-SHA256 with the deterministic
- *     `MOCK_WEBHOOK_SECRET` so `verifyWebhook(raw, sig)` returns true for
- *     any signature the mock itself produced.
- *   - In-memory `Map<orderId, PaymentOrder>` survives per process. State is
- *     intentionally not persisted — tests reset between runs by recreating
- *     the provider instance.
- *
- * Mocks-only operations:
- *   - `emitWebhook(event)` synchronously fires a webhook payload through a
- *     consumer-supplied callback so end-to-end tests can drive a
- *     payment.captured / payment.failed / order.paid event without leaving
- *     the process. Registered via `setWebhookSink(fn)`.
- */
-import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
-import { IPaymentProvider } from "../../../../contracts";
-const MOCK_WEBHOOK_SECRET = "appkit-mock-razorpay-webhook-secret-v1";
-export class MockRazorpayProvider extends IPaymentProvider {
-    constructor() {
-        super(...arguments);
-        this.name = "razorpay-mock";
-        this.orders = new Map();
-        this.captures = new Map();
-        this.webhookSink = null;
-    }
-    setWebhookSink(sink) {
-        this.webhookSink = sink;
-    }
-    async createOrder(amount, currency, metadata) {
-        const order = {
-            id: `order_mock_${randomBytes(8).toString("hex")}`,
-            amount,
-            currency,
-            status: "created",
-            receipt: `rcpt_mock_${Date.now()}`,
-            metadata,
-            createdAt: new Date().toISOString(),
-        };
-        this.orders.set(order.id, order);
-        return order;
-    }
-    verifyWebhook(payload, signature) {
-        if (signature.length !== 64)
-            return false;
-        const expected = createHmac("sha256", MOCK_WEBHOOK_SECRET)
-            .update(payload)
-            .digest("hex");
-        return timingSafeEqual(Buffer.from(expected, "hex"), Buffer.from(signature, "hex"));
-    }
-    async capturePayment(orderId) {
-        const order = this.orders.get(orderId);
-        if (!order) {
-            throw Object.assign(new Error(`Mock order not found: ${orderId}`), {
-                httpStatus: 404,
-            });
-        }
-        const capture = {
-            id: `pay_mock_${randomBytes(8).toString("hex")}`,
-            orderId,
-            amount: order.amount,
-            currency: order.currency,
-            status: "captured",
-            capturedAt: new Date().toISOString(),
-        };
-        this.captures.set(capture.id, capture);
-        this.orders.set(orderId, { ...order, status: "paid" });
-        return capture;
-    }
-    async refund(paymentId, amount) {
-        const capture = this.captures.get(paymentId);
-        const refund = {
-            id: `rfnd_mock_${randomBytes(8).toString("hex")}`,
-            paymentId,
-            amount: amount ?? capture?.amount ?? 0,
-            currency: capture?.currency ?? "INR",
-            status: "processed",
-            createdAt: new Date().toISOString(),
-        };
-        return refund;
-    }
-    async getOrder(orderId) {
-        const order = this.orders.get(orderId);
-        if (!order) {
-            throw Object.assign(new Error(`Mock order not found: ${orderId}`), {
-                httpStatus: 404,
-            });
-        }
-        return order;
-    }
-    /**
-     * Mocks-only — fire a webhook event through the consumer-registered sink.
-     * Used by `/api/admin/dev/emit-payment-webhook` to drive end-to-end test
-     * flows. Throws if no sink is registered.
-     */
-    async emitWebhook(payload) {
-        if (!this.webhookSink) {
-            throw new Error("MockRazorpayProvider.emitWebhook called with no webhook sink registered. " +
-                "Call provider.setWebhookSink(handler) at startup.");
-        }
-        const rawBody = JSON.stringify({
-            event: payload.event,
-            payload: {
-                order: { entity: { id: payload.orderId, amount: payload.amount, currency: payload.currency } },
-                payment: { entity: { id: payload.paymentId, amount: payload.amount, currency: payload.currency } },
-            },
-        });
-        const signature = createHmac("sha256", MOCK_WEBHOOK_SECRET).update(rawBody).digest("hex");
-        await this.webhookSink(rawBody, signature, payload);
-    }
-}