@jsdev_ninja/core 0.12.5 → 0.12.7

package/dist/entities/Store.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-declare const StoreSchema: z.ZodObject<{
+export declare const clientTypesSchema: z.ZodEnum<["individual", "company"]>;
+export declare const StoreSchema: z.ZodObject<{
     id: z.ZodString;
     companyId: z.ZodString;
     name: z.ZodString;
@@ -43,5 +44,4 @@ declare const StoreSchema: z.ZodObject<{
     deliveryPrice?: number | undefined;
 }>;
 export type TStore = z.infer<typeof StoreSchema>;
-export {};
 //# sourceMappingURL=Store.d.ts.map

package/dist/entities/Store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../lib/entities/Store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcf,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}
+{"version":3,"file":"Store.d.ts","sourceRoot":"","sources":["../../lib/entities/Store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB,sCAAoC,CAAC;AAEnE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EActB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/entities/Store.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
-const clientTypesSchema = z.enum(["individual", "company"]);
-const StoreSchema = z.object({
+export const clientTypesSchema = z.enum(["individual", "company"]);
+export const StoreSchema = z.object({
     id: z.string(),
     companyId: z.string(),
     name: z.string(),

package/lib/entities/Discount/__tests__/engine.test.ts

@@ -0,0 +1,337 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { DiscountEngine } from "../engine";
+import { DiscountStrategyFactory } from "../factory";
+import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
+import { TDiscount } from "../types";
+
+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: TDiscount[] = [
+        {
+          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: TDiscount[] = [
+        {
+          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: TDiscount[] = [
+        {
+          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: Array<{
+        amount: number;
+        product: {
+          id: string;
+          price: number;
+        };
+      }> = [];
+      const discounts: TDiscount[] = [
+        {
+          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: TDiscount[] = [];
+      
+      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: TDiscount = {
+        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: TDiscount = {
+        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: TDiscount = {
+        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: TDiscount[] = [
+        {
+          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/lib/entities/Discount/__tests__/factory.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { DiscountStrategyFactory } from "../factory";
+import { DiscountStrategy } from "../strategy";
+import { TDiscount } from "../types";
+
+describe("DiscountStrategyFactory", () => {
+  beforeEach(() => {
+    DiscountStrategyFactory.clearStrategies();
+  });
+  
+  afterEach(() => {
+    DiscountStrategyFactory.clearStrategies();
+  });
+  
+  it("should register and get strategy", () => {
+    const mockStrategy: DiscountStrategy = {
+      canApply: () => false,
+      calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
+    };
+    
+    DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
+    
+    const discount: TDiscount = {
+      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: TDiscount = {
+      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: DiscountStrategy = {
+      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: DiscountStrategy = {
+      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/lib/entities/Discount/__tests__/integration.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { DiscountEngine } from "../engine";
+import { DiscountStrategyFactory } from "../factory";
+import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
+import { TDiscount } from "../types";
+
+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: TDiscount = {
+      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: TDiscount = {
+      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
+  });
+});