@jsdev_ninja/core 0.12.7 → 0.12.8

package/dist/entities/Discount/__tests__/engine.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=engine.test.d.ts.map

package/dist/entities/Discount/__tests__/engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.test.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/__tests__/engine.test.ts"],"names":[],"mappings":""}

package/dist/entities/Discount/__tests__/engine.test.js

@@ -0,0 +1,298 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { DiscountEngine } from "../engine";
+import { DiscountStrategyFactory } from "../factory";
+import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
+describe("DiscountEngine", () => {
+    beforeEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+        DiscountStrategyFactory.registerStrategy("bundle", new BundleDiscountStrategy());
+    });
+    afterEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+    });
+    describe("calculateDiscounts", () => {
+        it("should apply bundle discount correctly", () => {
+            const cart = [
+                {
+                    amount: 2,
+                    product: {
+                        id: "product1",
+                        price: 10,
+                    },
+                },
+                {
+                    amount: 1,
+                    product: {
+                        id: "product2",
+                        price: 15,
+                    },
+                },
+            ];
+            const discounts = [
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "bundle1",
+                    name: [{ lang: "he", value: "Buy 3 for $25" }],
+                    active: true,
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1", "product2"],
+                        requiredQuantity: 3,
+                        bundlePrice: 25,
+                    },
+                    conditions: {
+                        stackable: false,
+                    },
+                },
+            ];
+            const result = DiscountEngine.calculateDiscounts(cart, discounts);
+            expect(result.totalDiscount).toBe(10);
+            expect(result.appliedDiscounts).toHaveLength(1);
+            expect(result.appliedDiscounts[0].discountId).toBe("bundle1");
+            expect(result.items).toHaveLength(2);
+            // Check final prices
+            const product1Item = result.items.find(item => item.product.id === "product1");
+            expect(product1Item?.finalPrice).toBeCloseTo(7.14, 2); // 10 - (5.71/2) = 7.145
+            const product2Item = result.items.find(item => item.product.id === "product2");
+            expect(product2Item?.finalPrice).toBeCloseTo(10.71, 2); // 15 - 4.29 = 10.71
+        });
+        it("should handle multiple discounts", () => {
+            const cart = [
+                {
+                    amount: 4,
+                    product: {
+                        id: "product1",
+                        price: 10,
+                    },
+                },
+            ];
+            const discounts = [
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "bundle1",
+                    name: [{ lang: "he", value: "Buy 3 for $25" }],
+                    active: true,
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1"],
+                        requiredQuantity: 3,
+                        bundlePrice: 25,
+                    },
+                    conditions: {
+                        stackable: true, // Allow stacking
+                    },
+                },
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "bundle2",
+                    name: [{ lang: "he", value: "Buy 2 for $15" }],
+                    active: true,
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1"],
+                        requiredQuantity: 2,
+                        bundlePrice: 15,
+                    },
+                    conditions: {
+                        stackable: true,
+                    },
+                },
+            ];
+            const result = DiscountEngine.calculateDiscounts(cart, discounts);
+            expect(result.appliedDiscounts).toHaveLength(2);
+            expect(result.totalDiscount).toBeGreaterThan(0);
+        });
+        it("should filter out inactive discounts", () => {
+            const cart = [
+                {
+                    amount: 3,
+                    product: {
+                        id: "product1",
+                        price: 10,
+                    },
+                },
+            ];
+            const discounts = [
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "bundle1",
+                    name: [{ lang: "he", value: "Buy 3 for $25" }],
+                    active: false, // Inactive
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1"],
+                        requiredQuantity: 3,
+                        bundlePrice: 25,
+                    },
+                    conditions: {
+                        stackable: false,
+                    },
+                },
+            ];
+            const result = DiscountEngine.calculateDiscounts(cart, discounts);
+            expect(result.totalDiscount).toBe(0);
+            expect(result.appliedDiscounts).toHaveLength(0);
+        });
+        it("should handle empty cart", () => {
+            const cart = [];
+            const discounts = [
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "bundle1",
+                    name: [{ lang: "he", value: "Buy 3 for $25" }],
+                    active: true,
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1"],
+                        requiredQuantity: 3,
+                        bundlePrice: 25,
+                    },
+                    conditions: {
+                        stackable: false,
+                    },
+                },
+            ];
+            const result = DiscountEngine.calculateDiscounts(cart, discounts);
+            expect(result.totalDiscount).toBe(0);
+            expect(result.appliedDiscounts).toHaveLength(0);
+            expect(result.items).toHaveLength(0);
+        });
+        it("should handle empty discounts", () => {
+            const cart = [
+                {
+                    amount: 2,
+                    product: {
+                        id: "product1",
+                        price: 10,
+                    },
+                },
+            ];
+            const discounts = [];
+            const result = DiscountEngine.calculateDiscounts(cart, discounts);
+            expect(result.totalDiscount).toBe(0);
+            expect(result.appliedDiscounts).toHaveLength(0);
+            expect(result.items).toHaveLength(1);
+            expect(result.items[0].finalPrice).toBe(10); // No discount applied
+        });
+    });
+    describe("isDiscountActive", () => {
+        it("should return true for active discount", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: true,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+            };
+            expect(DiscountEngine.isDiscountActive(discount)).toBe(true);
+        });
+        it("should return false for inactive discount", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: false,
+                startDate: Date.now() - 1000,
+                endDate: Date.now() + 1000,
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+            };
+            expect(DiscountEngine.isDiscountActive(discount)).toBe(false);
+        });
+        it("should return false for expired discount", () => {
+            const discount = {
+                type: "Discount",
+                storeId: "store1",
+                companyId: "company1",
+                id: "bundle1",
+                name: [{ lang: "he", value: "Buy 3 for $25" }],
+                active: true,
+                startDate: Date.now() - 2000,
+                endDate: Date.now() - 1000, // Expired
+                variant: {
+                    variantType: "bundle",
+                    productsId: ["product1"],
+                    requiredQuantity: 3,
+                    bundlePrice: 25,
+                },
+            };
+            expect(DiscountEngine.isDiscountActive(discount)).toBe(false);
+        });
+    });
+    describe("getActiveDiscounts", () => {
+        it("should filter active discounts", () => {
+            const discounts = [
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "active1",
+                    name: [{ lang: "he", value: "Active Discount" }],
+                    active: true,
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1"],
+                        requiredQuantity: 3,
+                        bundlePrice: 25,
+                    },
+                },
+                {
+                    type: "Discount",
+                    storeId: "store1",
+                    companyId: "company1",
+                    id: "inactive1",
+                    name: [{ lang: "he", value: "Inactive Discount" }],
+                    active: false,
+                    startDate: Date.now() - 1000,
+                    endDate: Date.now() + 1000,
+                    variant: {
+                        variantType: "bundle",
+                        productsId: ["product1"],
+                        requiredQuantity: 3,
+                        bundlePrice: 25,
+                    },
+                },
+            ];
+            const activeDiscounts = DiscountEngine.getActiveDiscounts(discounts);
+            expect(activeDiscounts).toHaveLength(1);
+            expect(activeDiscounts[0].id).toBe("active1");
+        });
+    });
+});

package/dist/entities/Discount/__tests__/factory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=factory.test.d.ts.map

package/dist/entities/Discount/__tests__/factory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.test.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/__tests__/factory.test.ts"],"names":[],"mappings":""}

package/dist/entities/Discount/__tests__/factory.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { DiscountStrategyFactory } from "../factory";
+describe("DiscountStrategyFactory", () => {
+    beforeEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+    });
+    afterEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+    });
+    it("should register and get strategy", () => {
+        const mockStrategy = {
+            canApply: () => false,
+            calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
+        };
+        DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
+        const discount = {
+            type: "Discount",
+            storeId: "store1",
+            companyId: "company1",
+            id: "test1",
+            name: [{ lang: "he", value: "Test Discount" }],
+            active: true,
+            startDate: Date.now() - 1000,
+            endDate: Date.now() + 1000,
+            variant: {
+                variantType: "bundle",
+                productsId: ["product1"],
+                requiredQuantity: 3,
+                bundlePrice: 25,
+            },
+        };
+        const result = DiscountStrategyFactory.getStrategy(discount);
+        expect(result).toBe(mockStrategy);
+    });
+    it("should return null for unregistered strategy", () => {
+        const discount = {
+            type: "Discount",
+            storeId: "store1",
+            companyId: "company1",
+            id: "test1",
+            name: [{ lang: "he", value: "Test Discount" }],
+            active: true,
+            startDate: Date.now() - 1000,
+            endDate: Date.now() + 1000,
+            variant: {
+                variantType: "bundle",
+                productsId: ["product1"],
+                requiredQuantity: 3,
+                bundlePrice: 25,
+            },
+        };
+        const result = DiscountStrategyFactory.getStrategy(discount);
+        expect(result).toBeNull();
+    });
+    it("should get registered types", () => {
+        const mockStrategy = {
+            canApply: () => false,
+            calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
+        };
+        DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
+        DiscountStrategyFactory.registerStrategy("percentage", mockStrategy);
+        const types = DiscountStrategyFactory.getRegisteredTypes();
+        expect(types).toEqual(["bundle", "percentage"]);
+    });
+    it("should clear strategies", () => {
+        const mockStrategy = {
+            canApply: () => false,
+            calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
+        };
+        DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
+        expect(DiscountStrategyFactory.getRegisteredTypes()).toHaveLength(1);
+        DiscountStrategyFactory.clearStrategies();
+        expect(DiscountStrategyFactory.getRegisteredTypes()).toHaveLength(0);
+    });
+});

package/dist/entities/Discount/__tests__/integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=integration.test.d.ts.map

package/dist/entities/Discount/__tests__/integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.test.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/__tests__/integration.test.ts"],"names":[],"mappings":""}

package/dist/entities/Discount/__tests__/integration.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { DiscountEngine } from "../engine";
+import { DiscountStrategyFactory } from "../factory";
+import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
+describe("Discount System Integration", () => {
+    beforeEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+        DiscountStrategyFactory.registerStrategy("bundle", new BundleDiscountStrategy());
+    });
+    afterEach(() => {
+        DiscountStrategyFactory.clearStrategies();
+    });
+    it("should handle real-world bundle scenario", () => {
+        // Scenario: Buy 3 dairy products for $20
+        const cart = [
+            {
+                amount: 2, // 2 milk
+                product: {
+                    id: "milk",
+                    price: 8, // $8 each
+                },
+            },
+            {
+                amount: 1, // 1 yogurt
+                product: {
+                    id: "yogurt",
+                    price: 6, // $6 each
+                },
+            },
+            {
+                amount: 1, // 1 bread (not in bundle)
+                product: {
+                    id: "bread",
+                    price: 4, // $4 each
+                },
+            },
+        ];
+        const dairyBundle = {
+            type: "Discount",
+            storeId: "store1",
+            companyId: "company1",
+            id: "dairy-bundle",
+            name: [{ lang: "he", value: "3 Dairy Products for $20" }],
+            active: true,
+            startDate: Date.now() - 1000,
+            endDate: Date.now() + 1000,
+            variant: {
+                variantType: "bundle",
+                productsId: ["milk", "yogurt", "cheese"], // Dairy products
+                requiredQuantity: 3,
+                bundlePrice: 20,
+            },
+            conditions: {
+                stackable: false,
+            },
+        };
+        const result = DiscountEngine.calculateDiscounts(cart, [dairyBundle]);
+        // Original prices:
+        // milk: 2 × $8 = $16
+        // yogurt: 1 × $6 = $6
+        // bread: 1 × $4 = $4
+        // Total: $26
+        // Bundle applies to milk + yogurt (3 items for $20)
+        // Remaining: bread at $4
+        // New total: $24
+        expect(result.totalDiscount).toBe(2); // $26 - $24
+        expect(result.appliedDiscounts).toHaveLength(1);
+        expect(result.appliedDiscounts[0].discountId).toBe("dairy-bundle");
+        // Check individual item prices
+        const milkItem = result.items.find(item => item.product.id === "milk");
+        expect(milkItem?.finalPrice).toBeCloseTo(7.28, 2); // 8 - (1.45/2) = 7.275
+        const yogurtItem = result.items.find(item => item.product.id === "yogurt");
+        expect(yogurtItem?.finalPrice).toBeCloseTo(5.45, 2); // 6 - 0.55 = 5.45
+        const breadItem = result.items.find(item => item.product.id === "bread");
+        expect(breadItem?.finalPrice).toBe(4); // No discount
+    });
+    it("should handle BOGO scenario", () => {
+        // Scenario: Buy 2 Get 1 Free
+        const cart = [
+            {
+                amount: 3, // Buy 3 items
+                product: {
+                    id: "product1",
+                    price: 10, // $10 each
+                },
+            },
+        ];
+        const bogoDiscount = {
+            type: "Discount",
+            storeId: "store1",
+            companyId: "company1",
+            id: "bogo",
+            name: [{ lang: "he", value: "Buy 2 Get 1 Free" }],
+            active: true,
+            startDate: Date.now() - 1000,
+            endDate: Date.now() + 1000,
+            variant: {
+                variantType: "bundle",
+                productsId: ["product1"],
+                requiredQuantity: 3, // Buy 2 + get 1 free = 3 items
+                bundlePrice: 20, // Price of 2 items (10 × 2)
+            },
+            conditions: {
+                stackable: false,
+            },
+        };
+        const result = DiscountEngine.calculateDiscounts(cart, [bogoDiscount]);
+        // Original: 3 × $10 = $30
+        // Bundle: 3 items for $20
+        // Discount: $10
+        expect(result.totalDiscount).toBe(10);
+        expect(result.appliedDiscounts).toHaveLength(1);
+        expect(result.items[0].finalPrice).toBeCloseTo(6.67, 2); // $20 / 3
+    });
+});

package/dist/entities/Discount/__tests__/simple.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=simple.test.d.ts.map

package/dist/entities/Discount/__tests__/simple.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.test.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/__tests__/simple.test.ts"],"names":[],"mappings":""}