@mohasinac/appkit 3.0.6 → 3.1.1

package/dist/features/orders/repository/__tests__/orders.repository.test.js

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap, makeQuerySnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockBatch } = makeMockDb();
+vi.mock("../../../../providers/db-firebase", () => ({
+    getAdminDb: () => db,
+    prepareForFirestore: (data) => data,
+    BaseRepository: class {
+        get db() { return db; }
+        constructor(col) { this.collection = col; }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getCollection() { return db.collection(this.collection); }
+        mapDoc(snap) {
+            return { id: snap.id, ...snap.data() };
+        }
+        async findById(id) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const snap = await db.collection(this.collection).doc(id).get();
+            return snap.exists ? { id: snap.id, ...snap.data() } : null;
+        }
+        async findBy(field, value) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const snap = await db.collection(this.collection).where(field, "==", value).get();
+            return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
+        }
+        async update(id, data) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await db.collection(this.collection).doc(id).update(data);
+            return { id, ...data };
+        }
+    },
+}));
+vi.mock("../../../../monitoring", () => ({
+    serverLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+vi.mock("../../../../security", () => ({
+    ORDER_PII_FIELDS: ["shippingAddress.phone", "shippingAddress.fullName"],
+    encryptPiiFields: (data) => data,
+    decryptPiiFields: (data) => data,
+}));
+vi.mock("../../../../contracts/field-ops", () => ({
+    serverTimestamp: () => new Date(),
+}));
+vi.mock("../../schemas", async () => ({
+    ORDER_COLLECTION: "orders",
+    OrderStatusValues: {
+        PENDING: "pending",
+        CONFIRMED: "confirmed",
+        PROCESSING: "processing",
+        SHIPPED: "shipped",
+        DELIVERED: "delivered",
+        CANCELLED: "cancelled",
+        REFUNDED: "refunded",
+    },
+    createOrderId: () => "order-1-20260101-abc123",
+}));
+import { OrderRepository } from "../orders.repository";
+const repo = new OrderRepository();
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.update.mockResolvedValue(undefined);
+    mockDocRef.delete.mockResolvedValue(undefined);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    db.collection.mockReturnValue(mockCollection);
+    db.batch.mockReturnValue(mockBatch);
+});
+describe("OrderRepository.cancelOrder", () => {
+    it("sets status: cancelled", async () => {
+        mockDocRef.update.mockResolvedValue(undefined);
+        await repo.cancelOrder("order-1", "user changed mind");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "cancelled" }));
+    });
+    it("stores cancellation reason", async () => {
+        await repo.cancelOrder("order-1", "payment failed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ cancellationReason: "payment failed" }));
+    });
+});
+describe("OrderRepository.updateStatus", () => {
+    it("updates status and updatedAt", async () => {
+        await repo.updateStatus("order-1", "shipped");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "shipped", updatedAt: expect.any(Date) }));
+    });
+});
+describe("OrderRepository.hasUserPurchased", () => {
+    it("returns true when confirmed order exists for user + product", async () => {
+        const docs = makeQuerySnap([
+            { id: "o1", data: { userId: "user-1", productId: "product-x", status: "confirmed" } },
+        ]);
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(true);
+    });
+    it("returns true for DELIVERED status", async () => {
+        const docs = makeQuerySnap([
+            { id: "o1", data: { userId: "user-1", productId: "product-x", status: "delivered" } },
+        ]);
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(true);
+    });
+    it("returns false for CANCELLED status", async () => {
+        const docs = makeQuerySnap([
+            { id: "o1", data: { userId: "user-1", productId: "product-x", status: "cancelled" } },
+        ]);
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(false);
+    });
+    it("returns false when no orders exist", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        const result = await repo.hasUserPurchased("user-1", "product-x");
+        expect(result).toBe(false);
+    });
+});
+describe("OrderRepository.countByUserAndProduct", () => {
+    it("returns query size (active statuses)", async () => {
+        mockQuery.get.mockResolvedValue({ ...makeQuerySnap([
+                { id: "o1", data: { status: "pending" } },
+                { id: "o2", data: { status: "delivered" } },
+            ]), size: 2 });
+        const count = await repo.countByUserAndProduct("user-1", "product-x");
+        expect(count).toBe(2);
+    });
+});
+describe("OrderRepository.getTimedOutPending", () => {
+    it("filters by status=pending, paymentStatus=pending, createdAt < cutoff", async () => {
+        mockQuery.get.mockResolvedValue(makeQuerySnap([]));
+        await repo.getTimedOutPending(24);
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "pending");
+        expect(mockQuery.where).toHaveBeenCalledWith("paymentStatus", "==", "pending");
+        expect(mockQuery.where).toHaveBeenCalledWith("createdAt", "<", expect.any(Date));
+    });
+    it("returns docs with id, ref, and data", async () => {
+        const docs = makeQuerySnap([
+            { id: "o-timeout", data: { status: "pending", paymentStatus: "pending" } },
+        ]);
+        // Attach .ref to each doc
+        docs.docs[0].ref = { id: "o-timeout" };
+        mockQuery.get.mockResolvedValue(docs);
+        const result = await repo.getTimedOutPending(24);
+        expect(result[0].id).toBe("o-timeout");
+        expect(result[0].data).toBeDefined();
+    });
+});
+describe("OrderRepository.cancelInBatch", () => {
+    it("stages status: cancelled in caller batch, does NOT commit", () => {
+        const ref = { id: "order-1" };
+        repo.cancelInBatch(mockBatch, ref);
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ status: "cancelled", cancellationReason: "payment_timeout" }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});
+describe("OrderRepository.markPayoutRequested", () => {
+    it("stages payoutStatus: requested in caller batch, does NOT commit", () => {
+        const ref = { id: "order-1" };
+        repo.markPayoutRequested(mockBatch, ref, "payout-123");
+        expect(mockBatch.update).toHaveBeenCalledWith(ref, expect.objectContaining({ payoutStatus: "requested", payoutId: "payout-123" }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});
+describe("OrderRepository.postRefundEvent", () => {
+    it("appends refund event to refunds array, sets contestable: false", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap({
+            status: "delivered",
+            refunds: [],
+            totalPrice: 10000,
+        }));
+        const event = { type: "partial", amountInPaise: 5000, reason: "damaged", refundedBy: "admin-1", refundedAt: new Date() };
+        await repo.postRefundEvent("order-1", event);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ contestable: false, refunds: [event] }));
+    });
+    it("becomeRefunded=true → sets status: refunded", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap({ status: "delivered", refunds: [], totalPrice: 10000 }));
+        const event = { type: "full", amountInPaise: 10000, reason: "return", refundedBy: "admin-1", refundedAt: new Date() };
+        await repo.postRefundEvent("order-1", event, true);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "refunded" }));
+    });
+    it("order not found → throws NotFoundError", async () => {
+        mockDocRef.get.mockResolvedValue(makeSnap(null));
+        const { NotFoundError } = await import("../../../../errors");
+        await expect(repo.postRefundEvent("nonexistent", {})).rejects.toBeInstanceOf(NotFoundError);
+    });
+});
+describe("OrderRepository.createFromAuction", () => {
+    it("stages order creation in caller batch with correct fields", () => {
+        mockCollection.doc.mockReturnValue({ ...mockDocRef, id: "new-order-id" });
+        repo.createFromAuction(mockBatch, {
+            productId: "auction-test",
+            productTitle: "Test Auction",
+            userId: "user-1",
+            userName: "Ravi Kumar",
+            userEmail: "ravi@example.com",
+            storeId: "store-1",
+            amount: 10000,
+            currency: "INR",
+            auctionProductId: "auction-test",
+        });
+        expect(mockBatch.create).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({
+            productId: "auction-test",
+            userId: "user-1",
+            storeId: "store-1",
+            totalPrice: 10000,
+            status: "confirmed",
+        }));
+        expect(mockBatch.commit).not.toHaveBeenCalled();
+    });
+});

package/dist/features/payments/repository/__tests__/payout.repository.test.d.ts

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

package/dist/features/payments/repository/__tests__/payout.repository.test.js

@@ -0,0 +1,292 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { makeMockDb, makeSnap } from "../../../../../tests/helpers/mock-firestore";
+const { db, mockDocRef, mockCollection, mockQuery, mockTxn } = makeMockDb();
+vi.mock("../../../../providers/db-firebase/admin", () => ({
+    getAdminDb: () => db,
+}));
+vi.mock("../../../../providers/db-firebase", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        prepareForFirestore: (d) => d,
+    };
+});
+vi.mock("../../../../security", () => ({
+    encryptPiiFields: (d) => d,
+    decryptPiiFields: (d) => d,
+    addPiiIndices: (d) => d,
+    encryptPayoutBankAccount: (d) => d,
+    decryptPayoutBankAccount: (d) => d,
+    PAYOUT_PII_FIELDS: ["sellerName", "sellerEmail"],
+    PAYOUT_PII_INDEX_MAP: {},
+}));
+vi.mock("../../../../errors/normalize", () => ({
+    normalizeError: vi.fn(),
+}));
+import { PayoutRepository } from "../payout.repository";
+const repo = new PayoutRepository();
+function makePayoutDoc(overrides = {}) {
+    return {
+        id: "payout-misty-20260101-a1b2c3",
+        storeId: "store-pokemon-palace",
+        sellerName: "Misty Singh",
+        sellerEmail: "misty@pokemon.com",
+        amount: 50000, // paise
+        netAmount: 50000,
+        status: "pending",
+        orderIds: ["order-1-20260101-abc", "order-2-20260101-def"],
+        requestedAt: new Date(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        refundDeductions: [],
+        ...overrides,
+    };
+}
+beforeEach(() => {
+    vi.clearAllMocks();
+    db.collection.mockReturnValue(mockCollection);
+    mockCollection.doc.mockReturnValue(mockDocRef);
+    mockCollection.where.mockReturnValue(mockQuery);
+    mockQuery.where.mockReturnValue(mockQuery);
+    mockQuery.orderBy.mockReturnValue(mockQuery);
+    mockQuery.limit.mockReturnValue(mockQuery);
+    mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+    mockDocRef.get.mockResolvedValue(makeSnap(null));
+    mockDocRef.set.mockResolvedValue(undefined);
+    mockDocRef.update.mockResolvedValue(undefined);
+    db.runTransaction.mockImplementation(async (fn) => fn(mockTxn));
+    mockTxn.get.mockResolvedValue(makeSnap(null));
+    mockTxn.update.mockReturnValue(undefined);
+});
+// ---------------------------------------------------------------------------
+// create
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.create", () => {
+    it("creates payout with status: pending", async () => {
+        const result = await repo.create({
+            storeId: "store-1",
+            sellerName: "Arun",
+            sellerEmail: "arun@test.com",
+            amount: 10000,
+            orderIds: [],
+            paymentMethod: "upi",
+        });
+        expect(result.status).toBe("pending");
+    });
+    it("persists the payout to Firestore", async () => {
+        await repo.create({
+            storeId: "store-1",
+            sellerName: "Arun",
+            sellerEmail: "arun@test.com",
+            amount: 10000,
+            orderIds: [],
+            paymentMethod: "upi",
+        });
+        expect(mockDocRef.set).toHaveBeenCalledOnce();
+    });
+    it("sets requestedAt timestamp", async () => {
+        const result = await repo.create({
+            storeId: "store-1",
+            sellerName: "Arun",
+            sellerEmail: "arun@test.com",
+            amount: 10000,
+            orderIds: [],
+            paymentMethod: "upi",
+        });
+        expect(result.requestedAt).toBeInstanceOf(Date);
+    });
+});
+// ---------------------------------------------------------------------------
+// markProcessing
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.markProcessing", () => {
+    it("sets status: processing on the provided ref", async () => {
+        await repo.markProcessing(mockDocRef);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "processing" }));
+    });
+    it("sets processedAt timestamp", async () => {
+        await repo.markProcessing(mockDocRef);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ processedAt: expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// recordSuccess
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.recordSuccess", () => {
+    it("stores razorpayPayoutId on the payout", async () => {
+        await repo.recordSuccess(mockDocRef, "razorpay-payout-123", "processed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ razorpayPayoutId: "razorpay-payout-123" }));
+    });
+    it("stores razorpayStatus on the payout", async () => {
+        await repo.recordSuccess(mockDocRef, "payout-abc", "processed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ razorpayStatus: "processed" }));
+    });
+    it("sets updatedAt timestamp", async () => {
+        await repo.recordSuccess(mockDocRef, "payout-abc", "processed");
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ updatedAt: expect.any(Date) }));
+    });
+});
+// ---------------------------------------------------------------------------
+// recordFailure
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.recordFailure", () => {
+    it("isFinal=true → sets status: failed", async () => {
+        await repo.recordFailure(mockDocRef, 3, "Insufficient funds", true);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "failed" }));
+    });
+    it("isFinal=false → keeps status: pending (retry)", async () => {
+        await repo.recordFailure(mockDocRef, 1, "Timeout", false);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ status: "pending" }));
+    });
+    it("stores failureCount", async () => {
+        await repo.recordFailure(mockDocRef, 2, "Network error", false);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ failureCount: 2 }));
+    });
+    it("stores lastFailureReason", async () => {
+        await repo.recordFailure(mockDocRef, 1, "Account blocked", false);
+        expect(mockDocRef.update).toHaveBeenCalledWith(expect.objectContaining({ lastFailureReason: "Account blocked" }));
+    });
+});
+// ---------------------------------------------------------------------------
+// applyRefundDeduction
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.applyRefundDeduction", () => {
+    it("throws when payout not found in transaction", async () => {
+        mockTxn.get.mockResolvedValue(makeSnap(null));
+        await expect(repo.applyRefundDeduction("payout-ghost", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        })).rejects.toThrow(/not found/i);
+    });
+    it("throws when payout status is not pending", async () => {
+        const payout = makePayoutDoc({ status: "completed" });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        await expect(repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        })).rejects.toThrow(/status/i);
+    });
+    it("computes netAmount = amount - totalDeducted", async () => {
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 10000,
+        });
+        expect(result.netAmount).toBe(40000);
+    });
+    it("netAmount is floored at 0 when deduction exceeds amount", async () => {
+        const payout = makePayoutDoc({ amount: 5000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 10000, // more than amount
+        });
+        expect(result.netAmount).toBe(0);
+    });
+    it("accumulates multiple deductions correctly", async () => {
+        const existing = [{ orderId: "order-old", deductedAmount: 5000, appliedAt: new Date() }];
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: existing });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-new",
+            deductedAmount: 10000,
+        });
+        // total deducted = 5000 + 10000 = 15000, net = 50000 - 15000 = 35000
+        expect(result.netAmount).toBe(35000);
+    });
+    it("sets appliedAt on the deduction entry", async () => {
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        const result = await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        });
+        const lastDeduction = result.refundDeductions[result.refundDeductions.length - 1];
+        expect(lastDeduction.appliedAt).toBeInstanceOf(Date);
+    });
+    it("uses a Firestore transaction for atomic read-modify-write", async () => {
+        const payout = makePayoutDoc({ amount: 50000, refundDeductions: [] });
+        mockTxn.get.mockResolvedValue({ exists: true, id: payout.id, data: () => payout });
+        await repo.applyRefundDeduction("payout-1", {
+            orderId: "order-1",
+            deductedAmount: 100,
+        });
+        expect(db.runTransaction).toHaveBeenCalledOnce();
+        expect(mockTxn.get).toHaveBeenCalledOnce();
+        expect(mockTxn.update).toHaveBeenCalledOnce();
+    });
+});
+// ---------------------------------------------------------------------------
+// findPendingByStore
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.findPendingByStore", () => {
+    it("returns null when no pending payout found", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        const result = await repo.findPendingByStore("store-1");
+        expect(result).toBeNull();
+    });
+    it("queries storeId AND status=pending", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.findPendingByStore("store-abc");
+        expect(mockCollection.where).toHaveBeenCalledWith("storeId", "==", "store-abc");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "==", "pending");
+    });
+    it("applies limit of 1 (most recent only)", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.findPendingByStore("store-abc");
+        expect(mockQuery.limit).toHaveBeenCalledWith(1);
+    });
+    it("returns the payout when found", async () => {
+        const payout = makePayoutDoc({ status: "pending" });
+        mockQuery.get.mockResolvedValue({
+            docs: [{ id: payout.id, data: () => payout }],
+            empty: false,
+            size: 1,
+        });
+        const result = await repo.findPendingByStore("store-pokemon-palace");
+        expect(result).not.toBeNull();
+    });
+});
+// ---------------------------------------------------------------------------
+// getPaidOutOrderIds
+// ---------------------------------------------------------------------------
+describe("PayoutRepository.getPaidOutOrderIds", () => {
+    it("returns empty Set when no matching payouts", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        const ids = await repo.getPaidOutOrderIds("store-1");
+        expect(ids.size).toBe(0);
+    });
+    it("collects all orderIds from matching payout documents", async () => {
+        const payout1 = makePayoutDoc({ orderIds: ["order-A", "order-B"] });
+        const payout2 = makePayoutDoc({ id: "payout-2", orderIds: ["order-C"] });
+        mockQuery.get.mockResolvedValue({
+            docs: [
+                { id: payout1.id, data: () => payout1 },
+                { id: payout2.id, data: () => payout2 },
+            ],
+            empty: false,
+            size: 2,
+        });
+        const ids = await repo.getPaidOutOrderIds("store-pokemon-palace");
+        expect(ids.has("order-A")).toBe(true);
+        expect(ids.has("order-B")).toBe(true);
+        expect(ids.has("order-C")).toBe(true);
+    });
+    it("queries storeId AND status in [pending, processing, completed]", async () => {
+        mockQuery.get.mockResolvedValue({ docs: [], empty: true, size: 0 });
+        await repo.getPaidOutOrderIds("store-1");
+        expect(mockCollection.where).toHaveBeenCalledWith("storeId", "==", "store-1");
+        expect(mockQuery.where).toHaveBeenCalledWith("status", "in", expect.arrayContaining(["pending", "processing", "completed"]));
+    });
+    it("handles payout with no orderIds field gracefully", async () => {
+        const payout = { ...makePayoutDoc(), orderIds: undefined };
+        mockQuery.get.mockResolvedValue({
+            docs: [{ id: payout.id, data: () => payout }],
+            empty: false,
+            size: 1,
+        });
+        const ids = await repo.getPaidOutOrderIds("store-1");
+        expect(ids.size).toBe(0);
+    });
+});

package/dist/features/products/api/[id]/route.d.ts

@@ -16,14 +16,14 @@ type RouteContext = {
     }>;
 };
 export declare function GET(_request: Request, context: RouteContext): Promise<NextResponse>;
-export declare const PATCH: (request: Request, context: {
+export declare const PATCH: (request: Request, context?: {
     params: Promise<{
         id: string;
     }>;
-}) => Promise<Response>;
-export declare const DELETE: (request: Request, context: {
+} | undefined) => Promise<Response>;
+export declare const DELETE: (request: Request, context?: {
     params: Promise<{
         id: string;
     }>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;
 export { GET as productItemGET, PATCH as productItemPATCH, DELETE as productItemDELETE, };

package/dist/features/products/api/route.d.ts

@@ -14,6 +14,6 @@
  */
 import { NextResponse } from "next/server.js";
 export declare function GET(request: Request): Promise<NextResponse>;
-export declare const POST: (request: Request, context: {
+export declare const POST: (request: Request, context?: {
     params: Promise<Record<string, string>>;
-}) => Promise<Response>;
+} | undefined) => Promise<Response>;

package/dist/features/products/repository/__tests__/product-features.repository.test.d.ts

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