@jsdev_ninja/core 0.12.6 → 0.12.7

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

@@ -0,0 +1,215 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { DiscountEngine } from "../engine";
+import { DiscountStrategyFactory } from "../factory";
+import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
+import { TDiscount } from "../types";
+
+describe("Simple Discount System Tests", () => {
+  beforeEach(() => {
+    DiscountStrategyFactory.clearStrategies();
+    DiscountStrategyFactory.registerStrategy("bundle", new BundleDiscountStrategy());
+  });
+
+  it("should calculate basic 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);
+  });
+
+  it("should not apply inactive discount", () => {
+    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 not apply discount when not enough items", () => {
+    const cart = [
+      {
+        amount: 2, // Only 2 items, need 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: 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);
+  });
+
+  it("should handle Buy 2 Get 1 Free scenario", () => {
+    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);
+  });
+
+  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);
+  });
+}); 

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

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "vitest";
+import { 
+  formatCurrency, 
+  formatCurrencyString, 
+  ensureNonNegative, 
+  calculatePercentageDiscount 
+} from "../utils";
+
+describe("Discount Utils", () => {
+  describe("formatCurrency", () => {
+    it("should format numbers to 2 decimal places", () => {
+      expect(formatCurrency(10)).toBe(10.00);
+      expect(formatCurrency(10.123)).toBe(10.12);
+      expect(formatCurrency(10.125)).toBe(10.13); // Rounds up
+      expect(formatCurrency(10.124)).toBe(10.12); // Rounds down
+      expect(formatCurrency(0)).toBe(0.00);
+    });
+
+    it("should return a number type", () => {
+      const result = formatCurrency(10.123);
+      expect(typeof result).toBe("number");
+    });
+  });
+
+  describe("formatCurrencyString", () => {
+    it("should format numbers to 2 decimal places as string", () => {
+      expect(formatCurrencyString(10)).toBe("10.00");
+      expect(formatCurrencyString(10.123)).toBe("10.12");
+      expect(formatCurrencyString(10.125)).toBe("10.13");
+      expect(formatCurrencyString(0)).toBe("0.00");
+    });
+
+    it("should return a string type", () => {
+      const result = formatCurrencyString(10.123);
+      expect(typeof result).toBe("string");
+    });
+  });
+
+  describe("ensureNonNegative", () => {
+    it("should return 0 for negative values", () => {
+      expect(ensureNonNegative(-5)).toBe(0.00);
+      expect(ensureNonNegative(-0.01)).toBe(0.00);
+    });
+
+    it("should return formatted value for positive values", () => {
+      expect(ensureNonNegative(10.123)).toBe(10.12);
+      expect(ensureNonNegative(0)).toBe(0.00);
+    });
+  });
+
+  describe("calculatePercentageDiscount", () => {
+    it("should calculate percentage discount correctly", () => {
+      expect(calculatePercentageDiscount(100, 80)).toBe(20.00); // 20% discount
+      expect(calculatePercentageDiscount(50, 25)).toBe(50.00); // 50% discount
+      expect(calculatePercentageDiscount(100, 100)).toBe(0.00); // No discount
+    });
+
+    it("should handle edge cases", () => {
+      expect(calculatePercentageDiscount(0, 0)).toBe(0.00);
+      expect(calculatePercentageDiscount(100, 0)).toBe(100.00); // 100% discount
+    });
+
+    it("should return formatted number", () => {
+      const result = calculatePercentageDiscount(100, 90.5);
+      expect(typeof result).toBe("number");
+      expect(result).toBe(9.50); // 9.5% discount
+    });
+  });
+}); 

package/lib/entities/Discount/engine.ts

@@ -0,0 +1,129 @@
+import { TDiscount, AppliedDiscount, DiscountContext } from "./types";
+import { DiscountStrategyFactory } from "./factory";
+
+export class DiscountEngine {
+  static calculateDiscounts(
+    cart: Array<{
+      amount: number;
+      product: {
+        id: string;
+        price: number;
+      };
+    }>,
+    discounts: TDiscount[],
+    user?: Record<string, unknown>
+  ): {
+    items: Array<{
+      amount: number;
+      product: {
+        id: string;
+        price: number;
+      };
+      originalPrice: number;
+      finalPrice: number;
+      finalDiscount: number;
+      appliedDiscounts: string[];
+    }>;
+    totalDiscount: number;
+    appliedDiscounts: AppliedDiscount[];
+  } {
+    const context: DiscountContext = {
+      cart,
+      user,
+      appliedDiscounts: [],
+    };
+    
+    // Filter active discounts
+    const activeDiscounts = this.filterActiveDiscounts(discounts);
+    
+    // Apply discounts
+    const appliedDiscounts: AppliedDiscount[] = [];
+    
+    for (const discount of activeDiscounts) {
+      const strategy = DiscountStrategyFactory.getStrategy(discount);
+      if (!strategy) continue;
+      
+      // Check if discount can be applied
+      if (!strategy.canApply(discount, context)) continue;
+      
+      // Check if discount is stackable
+      if (!discount.conditions?.stackable && appliedDiscounts.length > 0) continue;
+      
+      // Calculate discount
+      const result = strategy.calculate(discount, context);
+      if (!result.applicable) continue;
+      
+      // Apply discount
+      appliedDiscounts.push({
+        discountId: discount.id,
+        discountName: discount.name[0]?.value || "Discount",
+        discountAmount: Number(result.discountAmount.toFixed(2)),
+        affectedItems: result.affectedItems,
+      });
+      
+      // Update context for next iteration
+      context.appliedDiscounts = appliedDiscounts;
+    }
+    
+    // Calculate final prices
+    const items = this.calculateFinalPrices(cart, appliedDiscounts);
+    
+    const totalDiscount = appliedDiscounts.reduce((sum, discount) => 
+      sum + discount.discountAmount, 0);
+    
+    return {
+      items,
+      totalDiscount: Number(totalDiscount.toFixed(2)),
+      appliedDiscounts,
+    };
+  }
+  
+  private static filterActiveDiscounts(discounts: TDiscount[]): TDiscount[] {
+    const now = Date.now();
+    return discounts.filter(discount => 
+      discount.active && 
+      discount.startDate <= now && 
+      discount.endDate >= now
+    );
+  }
+  
+  private static calculateFinalPrices(
+    cart: DiscountContext["cart"], 
+    appliedDiscounts: AppliedDiscount[]
+  ) {
+    return cart.map(item => {
+      const itemDiscounts = appliedDiscounts.filter(discount =>
+        discount.affectedItems.some(affected => affected.productId === item.product.id)
+      );
+      
+      const totalItemDiscount = itemDiscounts.reduce((sum, discount) => {
+        const affectedItem = discount.affectedItems.find(affected => 
+          affected.productId === item.product.id);
+        return sum + (affectedItem?.discountAmount || 0);
+      }, 0);
+      
+      const discountPerUnit = totalItemDiscount / item.amount;
+      const finalPrice = item.product.price - discountPerUnit;
+      
+      return {
+        amount: item.amount,
+        product: item.product,
+        originalPrice: Number(item.product.price.toFixed(2)),
+        finalPrice: Number(Math.max(0, finalPrice).toFixed(2)),
+        finalDiscount: Number(totalItemDiscount.toFixed(2)),
+        appliedDiscounts: itemDiscounts.map(d => d.discountId),
+      };
+    });
+  }
+  
+  static isDiscountActive(discount: TDiscount): boolean {
+    const now = Date.now();
+    return discount.active && 
+           discount.startDate <= now && 
+           discount.endDate >= now;
+  }
+  
+  static getActiveDiscounts(discounts: TDiscount[]): TDiscount[] {
+    return this.filterActiveDiscounts(discounts);
+  }
+} 

package/lib/entities/Discount/factory.ts

@@ -0,0 +1,25 @@
+import { TDiscount } from "./types";
+import { DiscountStrategy } from "./strategy";
+import { BundleDiscountStrategy } from "./strategies/BundleStrategy";
+
+export class DiscountStrategyFactory {
+  private static strategies: Map<string, DiscountStrategy> = new Map([
+    ["bundle", new BundleDiscountStrategy()],
+  ]);
+  
+  static getStrategy(discount: TDiscount): DiscountStrategy | null {
+    return this.strategies.get(discount.variant.variantType) || null;
+  }
+  
+  static registerStrategy(type: string, strategy: DiscountStrategy): void {
+    this.strategies.set(type, strategy);
+  }
+  
+  static getRegisteredTypes(): string[] {
+    return Array.from(this.strategies.keys());
+  }
+  
+  static clearStrategies(): void {
+    this.strategies.clear();
+  }
+} 

package/lib/entities/Discount/index.ts

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./strategy";
+export * from "./factory";
+export * from "./engine";
+export * from "./strategies/BundleStrategy";
+export * from "./utils";
+
+// Re-export the main discount schema for backward compatibility
+export { DiscountSchema } from "./types";
+export type { TDiscount } from "./types";

package/lib/entities/Discount/strategies/BundleStrategy.ts

@@ -0,0 +1,123 @@
+import { DiscountStrategy } from "../strategy";
+import { TDiscount, DiscountResult, DiscountContext } from "../types";
+
+export class BundleDiscountStrategy implements DiscountStrategy {
+  canApply(discount: TDiscount, context: DiscountContext): boolean {
+    if (discount.variant.variantType !== "bundle") return false;
+    
+    // Check if discount is active
+    if (!this.isDiscountActive(discount)) return false;
+    
+    const { productsId, requiredQuantity } = discount.variant;
+    
+    // Check if cart has enough of the required products
+    const totalQuantity = this.getTotalQuantity(context.cart, productsId);
+    
+    return totalQuantity >= requiredQuantity;
+  }
+  
+  calculate(discount: TDiscount, context: DiscountContext): DiscountResult {
+    if (discount.variant.variantType !== "bundle") {
+      return { applicable: false, discountAmount: 0, affectedItems: [] };
+    }
+    
+    const { productsId, requiredQuantity, bundlePrice } = discount.variant;
+    
+    // Get applicable items (only the products in the bundle)
+    const applicableItems = context.cart.filter(item => 
+      productsId.includes(item.product.id));
+    
+    const totalQuantity = this.getTotalQuantity(context.cart, productsId);
+    const bundleCount = Math.floor(totalQuantity / requiredQuantity);
+    
+    if (bundleCount === 0) {
+      return { applicable: false, discountAmount: 0, affectedItems: [] };
+    }
+    
+    // Calculate original price for bundled items
+    const originalPrice = this.calculateOriginalPrice(applicableItems);
+    
+    // Calculate discounted price
+    const cartTotalQuantity = this.getTotalQuantity(context.cart, productsId);
+    const discountedPrice = this.calculateDiscountedPrice(
+      originalPrice, 
+      bundlePrice, 
+      bundleCount,
+      requiredQuantity,
+      cartTotalQuantity
+    );
+    
+    const totalDiscount = originalPrice - discountedPrice;
+    
+    // Distribute discount proportionally among items
+    const affectedItems = this.distributeDiscount(applicableItems, totalDiscount, originalPrice);
+    
+    return {
+      applicable: true,
+      discountAmount: Number(totalDiscount.toFixed(2)),
+      affectedItems,
+    };
+  }
+  
+  private isDiscountActive(discount: TDiscount): boolean {
+    const now = Date.now();
+    return discount.active && 
+           discount.startDate <= now && 
+           discount.endDate >= now;
+  }
+  
+  private getTotalQuantity(cart: DiscountContext["cart"], productIds: string[]): number {
+    return cart
+      .filter(item => productIds.includes(item.product.id))
+      .reduce((sum, item) => sum + item.amount, 0);
+  }
+  
+  private calculateOriginalPrice(items: DiscountContext["cart"]): number {
+    return items.reduce((sum, item) => 
+      sum + (item.product.price * item.amount), 0);
+  }
+  
+  private calculateDiscountedPrice(
+    originalPrice: number, 
+    bundlePrice: number, 
+    bundleCount: number,
+    requiredQuantity: number,
+    totalQuantity: number
+  ): number {
+    // For bundle discounts, we pay the bundle price for each complete bundle
+    // and full price for any remaining items
+    const bundledItemsPrice = bundlePrice * bundleCount;
+    
+    // For bundle discounts, we pay bundle price for complete bundles
+    // and full price for remaining items
+    // Since we're dealing with the total original price, we need to calculate
+    // how much of the original price represents the bundled items vs remaining items
+    const itemsInBundles = bundleCount * requiredQuantity;
+    const remainingItems = Math.max(0, totalQuantity - itemsInBundles);
+    
+    // Calculate the proportion of original price that represents remaining items
+    const remainingItemsPrice = (remainingItems / totalQuantity) * originalPrice;
+    
+    return bundledItemsPrice + remainingItemsPrice;
+  }
+  
+  private distributeDiscount(
+    items: DiscountContext["cart"], 
+    totalDiscount: number, 
+    originalPrice: number
+  ): DiscountResult["affectedItems"] {
+    const discountRatio = totalDiscount / originalPrice;
+    
+    return items.map(item => {
+      const itemDiscount = (item.product.price * item.amount) * discountRatio;
+      
+      return {
+        productId: item.product.id,
+        quantity: item.amount,
+        originalPrice: Number(item.product.price.toFixed(2)),
+        discountedPrice: Number((item.product.price - (itemDiscount / item.amount)).toFixed(2)),
+        discountAmount: Number(itemDiscount.toFixed(2)),
+      };
+    });
+  }
+}