@mohasinac/appkit 3.8.2 → 3.9.1

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

@@ -1,36 +0,0 @@
-/**
- * `resolvePaymentProvider` — decide between the real adapter and the
- * in-process mock based on site-settings feature flags.
- *
- * Resolution rule (single explicit boolean, no implicit fallback):
- *
- *   1. Read `siteSettings.featureFlags.useMockPayment`.
- *   2. If the flag is `true` and `process.env.NODE_ENV !== "production"` →
- *      return the mock provider.
- *   3. If the flag is `true` and `process.env.NODE_ENV === "production"` →
- *      THROW. Production must never run with a mock flag set. Loud failure
- *      is the contract.
- *   4. Otherwise → return the real provider supplied by the caller.
- *
- * The resolver is intentionally provider-agnostic (it accepts factories so
- * the consumer's `providers.config.ts` controls instantiation), keeping this
- * file zero-dep on the Razorpay SDK chain.
- *
- * Shipping has no equivalent resolver: the manual shipping provider makes no
- * external API calls, so there is nothing to mock — `providers.config.ts`
- * registers `ManualShippingProvider` directly.
- */
-import type { IPaymentProvider } from "../../../contracts";
-export interface ProviderResolutionContext {
-    readonly nodeEnv: string;
-    readonly siteSettings: {
-        readonly featureFlags?: {
-            readonly useMockPayment?: boolean;
-        };
-    };
-}
-export interface PaymentResolutionFactories {
-    readonly real: () => Promise<IPaymentProvider> | IPaymentProvider;
-    readonly mock: () => Promise<IPaymentProvider> | IPaymentProvider;
-}
-export declare function resolvePaymentProvider(ctx: ProviderResolutionContext, factories: PaymentResolutionFactories): Promise<IPaymentProvider>;

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

@@ -1,31 +0,0 @@
-/**
- * `resolvePaymentProvider` — decide between the real adapter and the
- * in-process mock based on site-settings feature flags.
- *
- * Resolution rule (single explicit boolean, no implicit fallback):
- *
- *   1. Read `siteSettings.featureFlags.useMockPayment`.
- *   2. If the flag is `true` and `process.env.NODE_ENV !== "production"` →
- *      return the mock provider.
- *   3. If the flag is `true` and `process.env.NODE_ENV === "production"` →
- *      THROW. Production must never run with a mock flag set. Loud failure
- *      is the contract.
- *   4. Otherwise → return the real provider supplied by the caller.
- *
- * The resolver is intentionally provider-agnostic (it accepts factories so
- * the consumer's `providers.config.ts` controls instantiation), keeping this
- * file zero-dep on the Razorpay SDK chain.
- *
- * Shipping has no equivalent resolver: the manual shipping provider makes no
- * external API calls, so there is nothing to mock — `providers.config.ts`
- * registers `ManualShippingProvider` directly.
- */
-export async function resolvePaymentProvider(ctx, factories) {
-    const want = ctx.siteSettings.featureFlags?.useMockPayment === true;
-    if (want && ctx.nodeEnv === "production") {
-        throw new Error("[providers] siteSettings.featureFlags.useMockPayment is TRUE in production. " +
-            "The mock payment provider must never run in production. Set the flag to false " +
-            "in Admin → Site Settings, or unset NODE_ENV=production for the deploy.");
-    }
-    return want ? await factories.mock() : await factories.real();
-}

package/dist/_internal/server/providers/shipping/shiprocket-mock.d.ts

@@ -1,29 +0,0 @@
-/**
- * `MockShiprocketProvider` — in-process mock implementing `IShippingProvider`.
- *
- * Replaces the orphaned `/api/dev/mock-shiprocket/**` HTTP routes (deleted
- * in Track H). State is per-process; status progression is deterministic so
- * tests can assert against a known sequence.
- */
-import type { CreateShipmentInput, IShippingProvider, ServiceabilityResult, Shipment, TrackingInfo } from "../../../../contracts";
-export type ShipmentEvent = "Pickup Scheduled" | "Pickup Completed" | "In Transit" | "Out for Delivery" | "Delivered" | "Cancelled";
-export type ShipmentEventSink = (trackingId: string, event: ShipmentEvent, shipment: Shipment) => Promise<void> | void;
-export declare class MockShiprocketProvider implements IShippingProvider {
-    readonly name: "shiprocket-mock";
-    private readonly shipments;
-    private eventSink;
-    setEventSink(sink: ShipmentEventSink | null): void;
-    createShipment(data: CreateShipmentInput): Promise<Shipment>;
-    trackShipment(trackingId: string): Promise<TrackingInfo>;
-    cancelShipment(shipmentId: string): Promise<void>;
-    private findShipmentById;
-    private notifyCancellation;
-    checkServiceability(pincode: string, weight: number): Promise<ServiceabilityResult>;
-    generateLabel(shipmentId: string): Promise<ArrayBuffer>;
-    /**
-     * Mocks-only — advance a shipment's tracking status and fire a tracking
-     * event through the consumer-registered sink. Used by
-     * `/api/admin/dev/emit-shipping-event` to drive end-to-end test flows.
-     */
-    emitTrackingEvent(trackingId: string, event: ShipmentEvent): Promise<void>;
-}

package/dist/_internal/server/providers/shipping/shiprocket-mock.js

@@ -1,152 +0,0 @@
-/**
- * `MockShiprocketProvider` — in-process mock implementing `IShippingProvider`.
- *
- * Replaces the orphaned `/api/dev/mock-shiprocket/**` HTTP routes (deleted
- * in Track H). State is per-process; status progression is deterministic so
- * tests can assert against a known sequence.
- */
-import { randomBytes } from "node:crypto";
-const PICKUP_SCHEDULED = "Pickup Scheduled";
-const TRACKING_PROGRESSION = [
-    PICKUP_SCHEDULED,
-    "Pickup Completed",
-    "In Transit",
-    "Out for Delivery",
-    "Delivered",
-];
-export class MockShiprocketProvider {
-    constructor() {
-        this.name = "shiprocket-mock";
-        this.shipments = new Map();
-        this.eventSink = null;
-    }
-    setEventSink(sink) {
-        this.eventSink = sink;
-    }
-    async createShipment(data) {
-        const trackingId = `MOCK${randomBytes(5).toString("hex").toUpperCase()}`;
-        const id = `shp_mock_${randomBytes(8).toString("hex")}`;
-        const courier = "MockExpress";
-        const initialEvent = {
-            status: PICKUP_SCHEDULED,
-            location: data.pickup.city,
-            timestamp: new Date().toISOString(),
-            description: "Pickup scheduled with carrier",
-        };
-        this.shipments.set(trackingId, {
-            id,
-            trackingId,
-            orderId: data.orderId,
-            courier,
-            createdAt: initialEvent.timestamp,
-            events: [initialEvent],
-        });
-        return {
-            id,
-            trackingId,
-            orderId: data.orderId,
-            status: initialEvent.status,
-            courier,
-            createdAt: initialEvent.timestamp,
-        };
-    }
-    async trackShipment(trackingId) {
-        const shipment = this.shipments.get(trackingId);
-        if (!shipment) {
-            throw Object.assign(new Error(`Mock shipment not found: ${trackingId}`), {
-                httpStatus: 404,
-            });
-        }
-        return {
-            trackingId,
-            currentStatus: shipment.events[shipment.events.length - 1]?.status ?? "Unknown",
-            events: [...shipment.events],
-        };
-    }
-    async cancelShipment(shipmentId) {
-        const entry = this.findShipmentById(shipmentId);
-        if (!entry) {
-            throw Object.assign(new Error(`Mock shipment not found: ${shipmentId}`), {
-                httpStatus: 404,
-            });
-        }
-        const [trackingId, ship] = entry;
-        ship.events.push({
-            status: "Cancelled",
-            location: ship.events[ship.events.length - 1]?.location ?? "Origin",
-            timestamp: new Date().toISOString(),
-            description: "Mock shipment cancelled",
-        });
-        await this.notifyCancellation(trackingId, ship);
-    }
-    findShipmentById(shipmentId) {
-        for (const entry of this.shipments) {
-            if (entry[1].id === shipmentId)
-                return entry;
-        }
-        return null;
-    }
-    async notifyCancellation(trackingId, ship) {
-        if (!this.eventSink)
-            return;
-        await this.eventSink(trackingId, "Cancelled", {
-            id: ship.id,
-            trackingId,
-            orderId: ship.orderId,
-            status: "Cancelled",
-            courier: ship.courier,
-            createdAt: ship.createdAt,
-        });
-    }
-    async checkServiceability(pincode, weight) {
-        // Mock policy: every pincode is serviceable; rate scales with weight.
-        return {
-            isServiceable: true,
-            couriers: [
-                { name: "MockExpress", estimatedDays: 3, rate: Math.round(60 + weight * 25) },
-                { name: "MockEconomy", estimatedDays: 5, rate: Math.round(40 + weight * 18) },
-            ],
-        };
-    }
-    async generateLabel(shipmentId) {
-        void shipmentId;
-        // Mock label: a tiny PDF-like blob. Production tests never read the
-        // bytes — they assert the API contract returns an ArrayBuffer.
-        const placeholder = new TextEncoder().encode(`%PDF-MOCK\n${shipmentId}\n`);
-        return placeholder.buffer.slice(placeholder.byteOffset, placeholder.byteOffset + placeholder.byteLength);
-    }
-    /**
-     * Mocks-only — advance a shipment's tracking status and fire a tracking
-     * event through the consumer-registered sink. Used by
-     * `/api/admin/dev/emit-shipping-event` to drive end-to-end test flows.
-     */
-    async emitTrackingEvent(trackingId, event) {
-        const shipment = this.shipments.get(trackingId);
-        if (!shipment) {
-            throw new Error(`Mock shipment not found: ${trackingId}`);
-        }
-        if (!this.eventSink) {
-            throw new Error("MockShiprocketProvider.emitTrackingEvent called with no sink registered. " +
-                "Call provider.setEventSink(handler) at startup.");
-        }
-        if (event !== "Cancelled" && !TRACKING_PROGRESSION.includes(event)) {
-            throw new Error(`Unknown tracking event: ${event}`);
-        }
-        const last = shipment.events[shipment.events.length - 1];
-        const trackingEvent = {
-            status: event,
-            location: last?.location ?? "Origin",
-            timestamp: new Date().toISOString(),
-            description: `Mock event: ${event}`,
-        };
-        shipment.events.push(trackingEvent);
-        await this.eventSink(trackingId, event, {
-            id: shipment.id,
-            trackingId,
-            orderId: shipment.orderId,
-            status: event,
-            courier: shipment.courier,
-            createdAt: shipment.createdAt,
-        });
-    }
-}

package/dist/_internal/shared/types/__tests__/action-result.test.d.ts

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

package/dist/_internal/shared/types/__tests__/action-result.test.js

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { wrapAction, isOk, unwrap } from "../action-result";
-import { ValidationError } from "../../../../errors/validation-error";
-import { NotFoundError } from "../../../../errors/not-found-error";
-describe("wrapAction", () => {
-    it("returns ok envelope on success", async () => {
-        const r = await wrapAction(async () => 42);
-        expect(r.ok).toBe(true);
-        if (r.ok)
-            expect(r.data).toBe(42);
-    });
-    it("returns error envelope on thrown ValidationError → VALIDATION_FAILED", async () => {
-        const r = await wrapAction(async () => {
-            throw new ValidationError("bad");
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok) {
-            expect(r.code).toBe("VALIDATION_FAILED");
-            expect(r.error).toBe("bad");
-        }
-    });
-    it("returns error envelope on thrown NotFoundError → NOT_FOUND", async () => {
-        const r = await wrapAction(async () => {
-            throw new NotFoundError("user-1");
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok)
-            expect(r.code).toBe("NOT_FOUND");
-    });
-    it("returns error envelope on unknown Error → INTERNAL", async () => {
-        const r = await wrapAction(async () => {
-            throw new Error("oops");
-        });
-        expect(r.ok).toBe(false);
-        if (!r.ok)
-            expect(r.code).toBe("INTERNAL");
-    });
-    it("never throws — string throws also produce an envelope", async () => {
-        const r = await wrapAction(async () => {
-            throw "raw string";
-        });
-        expect(r.ok).toBe(false);
-    });
-});
-describe("isOk", () => {
-    it("narrows ok arm", async () => {
-        const r = await wrapAction(async () => "x");
-        if (isOk(r)) {
-            // type narrowed — `data` accessible
-            expect(r.data).toBe("x");
-        }
-    });
-});
-describe("unwrap", () => {
-    it("returns data on ok", async () => {
-        const r = await wrapAction(async () => 7);
-        expect(unwrap(r)).toBe(7);
-    });
-    it("throws on error", async () => {
-        const r = await wrapAction(async () => {
-            throw new ValidationError("bad");
-        });
-        expect(() => unwrap(r)).toThrow("bad");
-    });
-});

package/dist/errors/__tests__/error-mapping.test.d.ts

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

package/dist/errors/__tests__/error-mapping.test.js

@@ -1,122 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mapToHttpError, HTTP_ERROR_CODES } from "../error-mapping";
-import { ApiError } from "../api-error";
-import { ValidationError } from "../validation-error";
-import { AuthenticationError } from "../authentication-error";
-import { AuthorizationError } from "../authorization-error";
-import { NotFoundError } from "../not-found-error";
-import { DatabaseError } from "../database-error";
-import { RazorpayUnreachableError } from "../razorpay-unreachable";
-describe("mapToHttpError", () => {
-    describe("AppError subclasses", () => {
-        it("maps ValidationError → 400 VALIDATION_FAILED", () => {
-            const r = mapToHttpError(new ValidationError("bad email"));
-            expect(r.status).toBe(400);
-            expect(r.code).toBe(HTTP_ERROR_CODES.VALIDATION_FAILED);
-            expect(r.message).toBe("bad email");
-        });
-        it("maps AuthenticationError → 401 UNAUTHENTICATED", () => {
-            const r = mapToHttpError(new AuthenticationError("nope"));
-            expect(r.status).toBe(401);
-            expect(r.code).toBe(HTTP_ERROR_CODES.UNAUTHENTICATED);
-        });
-        it("maps AuthorizationError → 403 FORBIDDEN", () => {
-            const r = mapToHttpError(new AuthorizationError("denied"));
-            expect(r.status).toBe(403);
-            expect(r.code).toBe(HTTP_ERROR_CODES.FORBIDDEN);
-        });
-        it("maps NotFoundError → 404 NOT_FOUND", () => {
-            const r = mapToHttpError(new NotFoundError("missing"));
-            expect(r.status).toBe(404);
-            expect(r.code).toBe(HTTP_ERROR_CODES.NOT_FOUND);
-        });
-        it("maps RazorpayUnreachableError → 503 UPSTREAM_UNAVAILABLE", () => {
-            const r = mapToHttpError(new RazorpayUnreachableError("network"));
-            expect(r.status).toBe(503);
-            expect(r.code).toBe(HTTP_ERROR_CODES.UPSTREAM_UNAVAILABLE);
-        });
-        it("maps ApiError → its declared status + code", () => {
-            const r = mapToHttpError(new ApiError(418, "teapot"));
-            expect(r.status).toBe(418);
-            expect(r.code).toBe("API_ERROR");
-            expect(r.message).toBe("teapot");
-        });
-    });
-    describe("DatabaseError wrapping FirestoreError", () => {
-        it("unwraps numeric FirestoreError 5 → 404 NOT_FOUND", () => {
-            const dbErr = new DatabaseError("doc missing", { code: 5, message: "not-found" });
-            const r = mapToHttpError(dbErr);
-            expect(r.status).toBe(404);
-            expect(r.code).toBe(HTTP_ERROR_CODES.NOT_FOUND);
-        });
-        it("unwraps numeric FirestoreError 7 → 403 PERMISSION_DENIED", () => {
-            const r = mapToHttpError(new DatabaseError("denied", { code: 7 }));
-            expect(r.status).toBe(403);
-            expect(r.code).toBe(HTTP_ERROR_CODES.PERMISSION_DENIED);
-        });
-        it("unwraps numeric FirestoreError 10 → 409 CONCURRENT_MODIFICATION", () => {
-            const r = mapToHttpError(new DatabaseError("aborted", { code: 10 }));
-            expect(r.status).toBe(409);
-            expect(r.code).toBe(HTTP_ERROR_CODES.CONCURRENT_MODIFICATION);
-        });
-        it("falls back to 500 DATABASE_ERROR when inner cause is not FirestoreError", () => {
-            const r = mapToHttpError(new DatabaseError("disk full", undefined));
-            expect(r.status).toBe(500);
-        });
-    });
-    describe("bare FirestoreError-shaped objects", () => {
-        it("maps numeric code 7 → 403 PERMISSION_DENIED", () => {
-            const r = mapToHttpError({ code: 7, message: "permission-denied" });
-            expect(r.status).toBe(403);
-            expect(r.code).toBe(HTTP_ERROR_CODES.PERMISSION_DENIED);
-        });
-        it("maps string code permission-denied → 403", () => {
-            const r = mapToHttpError({ code: "permission-denied", message: "no" });
-            expect(r.status).toBe(403);
-            expect(r.code).toBe(HTTP_ERROR_CODES.PERMISSION_DENIED);
-        });
-    });
-    describe("Zod-shaped errors", () => {
-        it("maps Zod-like { issues } → 400 VALIDATION_FAILED with issues", () => {
-            const r = mapToHttpError({ issues: [{ path: ["email"], message: "bad" }] });
-            expect(r.status).toBe(400);
-            expect(r.code).toBe(HTTP_ERROR_CODES.VALIDATION_FAILED);
-            expect(r.issues).toHaveLength(1);
-        });
-    });
-    describe("Unknown errors", () => {
-        it("scrubs in production mode", () => {
-            const r = mapToHttpError(new Error("DB password=secret"), {
-                isProduction: true,
-            });
-            expect(r.status).toBe(500);
-            expect(r.message).toBe("An internal error occurred");
-        });
-        it("preserves message in dev mode", () => {
-            const r = mapToHttpError(new Error("specific dev message"));
-            expect(r.status).toBe(500);
-            expect(r.message).toBe("specific dev message");
-        });
-        it("handles string throws", () => {
-            const r = mapToHttpError("oops");
-            expect(r.status).toBe(500);
-            expect(r.message).toBe("oops");
-        });
-        it("handles undefined throws", () => {
-            const r = mapToHttpError(undefined);
-            expect(r.status).toBe(500);
-        });
-    });
-    describe("Legacy { status } objects", () => {
-        it("maps { status: 401 } → 401 UNAUTHENTICATED", () => {
-            const r = mapToHttpError({ status: 401, message: "auth" });
-            expect(r.status).toBe(401);
-            expect(r.code).toBe(HTTP_ERROR_CODES.UNAUTHENTICATED);
-        });
-        it("maps { statusCode: 404 } → 404 NOT_FOUND", () => {
-            const r = mapToHttpError({ statusCode: 404, message: "gone" });
-            expect(r.status).toBe(404);
-            expect(r.code).toBe(HTTP_ERROR_CODES.NOT_FOUND);
-        });
-    });
-});

package/dist/errors/__tests__/safe-read.test.d.ts

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

package/dist/errors/__tests__/safe-read.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { safeRead, installDegradedReadReporter } from "../safe-read";
-describe("safeRead", () => {
-    it("returns the data on success without invoking the reporter", async () => {
-        const reporter = vi.fn();
-        installDegradedReadReporter(reporter);
-        const result = await safeRead(async () => 42, {
-            route: "/test",
-            key: "k",
-            fallback: -1,
-        });
-        expect(result).toBe(42);
-        expect(reporter).not.toHaveBeenCalled();
-    });
-    it("returns the fallback and reports on failure", async () => {
-        const reporter = vi.fn();
-        installDegradedReadReporter(reporter);
-        const fallback = ["empty"];
-        const result = await safeRead(async () => {
-            throw new Error("boom");
-        }, { route: "/test", key: "k2", fallback });
-        expect(result).toBe(fallback);
-        expect(reporter).toHaveBeenCalledTimes(1);
-        const call = reporter.mock.calls[0][0];
-        expect(call.route).toBe("/test");
-        expect(call.key).toBe("k2");
-        expect(call.code).toBe("DEGRADED_READ");
-        expect(call.message).toBe("boom");
-    });
-    it("never throws when the reporter itself throws", async () => {
-        installDegradedReadReporter(() => {
-            throw new Error("reporter broken");
-        });
-        const result = await safeRead(async () => {
-            throw new Error("inner");
-        }, { route: "/x", key: "y", fallback: null });
-        expect(result).toBeNull();
-    });
-});

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

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