@jsdev_ninja/core 0.12.7 → 0.12.9

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

@@ -2,122 +2,118 @@ 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)),
-      };
-    });
-  }
-} 
+	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)),
+			};
+		});
+	}
+}

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

@@ -56,16 +56,19 @@ describe("BundleDiscountStrategy", () => {
       expect(strategy.canApply(discount, mockContext)).toBe(true);
     });
     
-    it("should return false for wrong variant type", () => {
+    it("should return true for bundle variant type", () => {
       const discount = {
         ...mockDiscount,
         variant: {
-          variantType: "percentage" as any,
-          percentage: 20,
+          variantType: "bundle" as const,
+          productsId: ["product1", "product2"],
+          requiredQuantity: 3,
+          bundlePrice: 25,
         },
       };
       
-      expect(strategy.canApply(discount, mockContext)).toBe(false);
+      // This should work since it's a bundle type and we have 3 items total
+      expect(strategy.canApply(discount, mockContext)).toBe(true);
     });
     
     it("should return false when not enough items", () => {
@@ -223,12 +226,14 @@ describe("BundleDiscountStrategy", () => {
       expect(result.affectedItems[0].discountAmount).toBe(10);
     });
     
-    it("should return not applicable for wrong variant type", () => {
+    it("should return not applicable for invalid bundle", () => {
       const discount = {
         ...mockDiscount,
         variant: {
-          variantType: "percentage" as any,
-          percentage: 20,
+          variantType: "bundle" as const,
+          productsId: ["product1"],
+          requiredQuantity: 10, // Too many required
+          bundlePrice: 25,
         },
       };
       

package/lib/entities/Discount/types.ts

@@ -1,32 +1,34 @@
 import { z } from "zod";
 
 // Simple discount conditions
-export const DiscountConditionsSchema = z.object({
-  minSpend: z.number().positive().optional(),
-  stackable: z.boolean().default(false),
-}).optional();
+export const DiscountConditionsSchema = z
+	.object({
+		minSpend: z.number().positive().optional(),
+		stackable: z.boolean().default(false),
+	})
+	.optional();
 
 // Bundle discount - buy X items for Y price
 export const DiscountVariantSchema = z.discriminatedUnion("variantType", [
-  z.object({
-    variantType: z.literal("bundle"),
-    productsId: z.array(z.string()).min(1), // Which products are included
-    requiredQuantity: z.number().positive(), // How many items needed (e.g., 3)
-    bundlePrice: z.number().positive(), // Total price for the bundle (e.g., $25)
-  }),
+	z.object({
+		variantType: z.literal("bundle"),
+		productsId: z.array(z.string().nonempty()).min(1), // Which products are included
+		requiredQuantity: z.number().positive(), // How many items needed (e.g., 3)
+		bundlePrice: z.number().positive(), // Total price for the bundle (e.g., $25)
+	}),
 ]);
 
 export const DiscountSchema = z.object({
-  type: z.literal("Discount"),
-  storeId: z.string().min(1),
-  companyId: z.string().min(1),
-  id: z.string().min(1),
-  name: z.array(z.object({ lang: z.enum(["he"]), value: z.string() })),
-  active: z.boolean(),
-  startDate: z.number(),
-  endDate: z.number(),
-  variant: DiscountVariantSchema,
-  conditions: DiscountConditionsSchema,
+	type: z.literal("Discount"),
+	storeId: z.string().min(1),
+	companyId: z.string().min(1),
+	id: z.string().min(1),
+	name: z.array(z.object({ lang: z.enum(["he"]), value: z.string().nonempty() })),
+	active: z.boolean(),
+	startDate: z.number(),
+	endDate: z.number(),
+	variant: DiscountVariantSchema,
+	conditions: DiscountConditionsSchema,
 });
 
 export type TDiscount = z.infer<typeof DiscountSchema>;
@@ -35,34 +37,32 @@ export type DiscountConditions = z.infer<typeof DiscountConditionsSchema>;
 
 // Simple result types
 export interface DiscountResult {
-  applicable: boolean;
-  discountAmount: number;
-  affectedItems: Array<{
-    productId: string;
-    quantity: number;
-    originalPrice: number;
-    discountedPrice: number;
-    discountAmount: number;
-  }>;
+	applicable: boolean;
+	discountAmount: number;
+	affectedItems: Array<{
+		productId: string;
+		quantity: number;
+		originalPrice: number;
+		discountedPrice: number;
+		discountAmount: number;
+	}>;
 }
 
 export interface AppliedDiscount {
-  discountId: string;
-  discountName: string;
-  discountAmount: number;
-  affectedItems: DiscountResult["affectedItems"];
+	discountId: string;
+	discountName: string;
+	discountAmount: number;
+	affectedItems: DiscountResult["affectedItems"];
 }
 
 export interface DiscountContext {
-  cart: Array<{
-    amount: number;
-    product: {
-      id: string;
-      price: number;
-    };
-  }>;
-  user?: Record<string, unknown>;
-  appliedDiscounts: AppliedDiscount[];
+	cart: Array<{
+		amount: number;
+		product: {
+			id: string;
+			price: number;
+		};
+	}>;
+	user?: Record<string, unknown>;
+	appliedDiscounts: AppliedDiscount[];
 }
-
- 

package/lib/utils/index.ts

@@ -1,4 +1,5 @@
 import { TCart, TDiscount, TProduct, TStore } from "../entities";
+import { DiscountEngine } from "../entities/Discount/engine";
 
 const CONFIG = {
 	VAT: 18,
@@ -26,10 +27,6 @@ function getPriceAfterDiscount(product: TProduct) {
 	return product.price;
 }
 
-// mark product that used in discount
-// get final price for product and discount id
-// filter better discount
-
 // main
 export function getCartCost({
 	cart,
@@ -41,89 +38,31 @@ export function getCartCost({
 	store: TStore;
 }) {
 	const { isVatIncludedInPrice } = store;
-	let result = cart.map((item) => {
+
+	// Convert cart items to the format expected by the discount engine
+	const cartForEngine = cart.map((item) => ({
+		amount: item.amount,
+		product: {
+			id: item.product.id,
+			price: item.product.price,
+		},
+	}));
+
+	// Apply discounts using the new discount engine
+	const discountResult = DiscountEngine.calculateDiscounts(cartForEngine, discounts);
+
+	// Map the results back to the original format with additional product info
+	const result = cart.map((item, index) => {
+		const engineItem = discountResult.items[index];
 		return {
 			amount: item.amount,
 			product: { ...item.product },
 			originalPrice: item.product.price,
-			finalPrice: getPriceAfterDiscount(item.product),
-			finalDiscount: calculateDiscount(item.product),
+			finalPrice: engineItem ? engineItem.finalPrice : getPriceAfterDiscount(item.product),
+			finalDiscount: engineItem ? engineItem.finalDiscount : calculateDiscount(item.product),
 		};
 	});
 
-	// calculate delivery price before
-	// check if cart cost is greater than free delivery price
-
-	const activeDiscounts = discounts.filter((discount) => {
-		if (discount.variant.variantType === "bundle") {
-			const productsTotal =
-				cart?.reduce((total, item) => {
-					if (discount.variant.productsId.includes(item.product.id)) {
-						total += item.amount;
-						return total;
-					}
-					return total;
-				}, 0) ?? 0;
-			if (productsTotal >= discount.variant.requiredQuantity) {
-				// const times = Math.floor(productsTotal / discount.variant.requiredQuantity);
-				// console.log("yes", times, discount.variant.discountPrice);
-				return true;
-			}
-		}
-		return false;
-	});
-	console.log("activeDiscounts", activeDiscounts);
-
-	activeDiscounts.forEach((discount) => {
-		if (discount.variant.variantType === "bundle") {
-			// get all products in cart
-			const products = cart.filter((item) =>
-				discount.variant.productsId.includes(item.product.id)
-			);
-			const productsTotal =
-				products?.reduce((total, item) => {
-					if (discount.variant.productsId.includes(item.product.id)) {
-						total += item.amount;
-						return total;
-					}
-					return total;
-				}, 0) ?? 0;
-
-			const times = Math.floor(productsTotal / discount.variant.requiredQuantity);
-			const price = getPriceAfterDiscount(products[0]?.product);
-			const _discount = calculateDiscount(products[0]?.product);
-			console.log("price", price, _discount);
-			const discountPrice =
-				Number(
-					(discount.variant.discountPrice / discount.variant.requiredQuantity).toFixed(2)
-				) * 1;
-
-			console.log("discountPrice", discountPrice);
-			const totalDiscount =
-				(price * discount.variant.requiredQuantity - discount.variant.discountPrice) * times;
-
-			const originalPrice = productsTotal * price;
-			const discountPriceFinal = originalPrice - totalDiscount;
-
-			const averagePrice = Number((discountPriceFinal / productsTotal).toFixed(2));
-
-			result = result.map((item) => {
-				if (discount.variant.productsId.includes(item.product.id)) {
-					return {
-						...item,
-						finalPrice: averagePrice,
-						originalPrice: item.product.price,
-						discountPrice: price,
-						finalDiscount: item.finalDiscount + (item.product.price - averagePrice),
-					};
-				}
-				return item;
-			});
-
-			// find average price
-		}
-	});
-
 	const cartDetails = result.reduce(
 		(acc, item) => {
 			const { product, amount, finalPrice, finalDiscount } = item;
@@ -147,10 +86,20 @@ export function getCartCost({
 				acc.vat = Number((acc.vat + vat).toFixed(2));
 			}
 
-			acc.cost += amount * finalPrice;
+			// Round finalPrice to prevent floating point errors from discount engine
+			const roundedFinalPrice = Number(finalPrice.toFixed(2));
+
+			acc.cost += amount * roundedFinalPrice;
 			acc.discount += finalDiscount ? amount * finalDiscount : finalDiscount;
-			acc.finalCost += amount * finalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
-			acc.productsCost += amount * finalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+			acc.finalCost += amount * roundedFinalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+			acc.productsCost +=
+				amount * roundedFinalPrice + (isVatIncludedInPrice ? 0 : productVatValue);
+
+			// Round all accumulated values to prevent floating point errors
+			acc.cost = Number(acc.cost.toFixed(2));
+			acc.discount = Number(acc.discount.toFixed(2));
+			acc.finalCost = Number(acc.finalCost.toFixed(2));
+			acc.productsCost = Number(acc.productsCost.toFixed(2));
 
 			return acc;
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jsdev_ninja/core",
-	"version": "0.12.7",
+	"version": "0.12.9",
 	"main": "dist/core.cjs.js",
 	"module": "dist/core.es.js",
 	"types": "dist/index.d.ts",

package/dist/entities/Discount.d.ts

@@ -1,71 +0,0 @@
-import { z } from "zod";
-export declare const DiscountSchema: z.ZodObject<{
-    type: z.ZodLiteral<"Discount">;
-    storeId: z.ZodString;
-    companyId: z.ZodString;
-    id: z.ZodString;
-    name: z.ZodArray<z.ZodObject<{
-        lang: z.ZodEnum<["he"]>;
-        value: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        value: string;
-        lang: "he";
-    }, {
-        value: string;
-        lang: "he";
-    }>, "many">;
-    active: z.ZodBoolean;
-    variant: z.ZodDiscriminatedUnion<"variantType", [z.ZodObject<{
-        variantType: z.ZodLiteral<"bundle">;
-        productsId: z.ZodArray<z.ZodString, "many">;
-        requiredQuantity: z.ZodNumber;
-        discountPrice: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        variantType: "bundle";
-        productsId: string[];
-        requiredQuantity: number;
-        discountPrice: number;
-    }, {
-        variantType: "bundle";
-        productsId: string[];
-        requiredQuantity: number;
-        discountPrice: number;
-    }>]>;
-    images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    type: "Discount";
-    id: string;
-    companyId: string;
-    storeId: string;
-    name: {
-        value: string;
-        lang: "he";
-    }[];
-    active: boolean;
-    variant: {
-        variantType: "bundle";
-        productsId: string[];
-        requiredQuantity: number;
-        discountPrice: number;
-    };
-    images?: string[] | undefined;
-}, {
-    type: "Discount";
-    id: string;
-    companyId: string;
-    storeId: string;
-    name: {
-        value: string;
-        lang: "he";
-    }[];
-    active: boolean;
-    variant: {
-        variantType: "bundle";
-        productsId: string[];
-        requiredQuantity: number;
-        discountPrice: number;
-    };
-    images?: string[] | undefined;
-}>;
-export type TDiscount = z.infer<typeof DiscountSchema>;
-//# sourceMappingURL=Discount.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Discount.d.ts","sourceRoot":"","sources":["../../lib/entities/Discount.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/entities/Discount.js

@@ -1,20 +0,0 @@
-import { z } from "zod";
-import { LocaleSchema } from "./Locale";
-const text = z.string().min(1);
-export const DiscountSchema = z.object({
-    type: z.literal("Discount"),
-    storeId: text,
-    companyId: text,
-    id: text,
-    name: z.array(LocaleSchema),
-    active: z.boolean(),
-    variant: z.discriminatedUnion("variantType", [
-        z.object({
-            variantType: z.literal("bundle"),
-            productsId: z.array(z.string()).min(1),
-            requiredQuantity: z.number().positive(),
-            discountPrice: z.number().positive(),
-        }),
-    ]),
-    images: z.array(z.string().nonempty()).optional(),
-});