@jsdev_ninja/core 0.13.27 → 0.13.28

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

@@ -1,215 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,138 +0,0 @@
-import { TDiscount, AppliedDiscount, DiscountContext } from "./types";
-import { DiscountStrategyFactory } from "./factory";
-
-// discount engine - calculate discounts and return final prices
-// should register all discount types
-// should receive all store discounts
-// should check active discount that should be applied on cart
-// should find best discount per product
-// should apply discount to if stackable or best one
-// any applyd discount should mark products that effected and price before and after and average price per product in cart
-// should return items list with all calculations and final prices and discounts
-
-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
-			// todo
-			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

@@ -1,25 +0,0 @@
-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/strategies/BundleStrategy.ts

@@ -1,119 +0,0 @@
-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)),
-			};
-		});
-	}
-}