@jsdev_ninja/core 0.12.7 → 0.12.8

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/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;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jsdev_ninja/core",
-	"version": "0.12.7",
+	"version": "0.12.8",
 	"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(),
-});

package/lib/entities/Discount.ts

@@ -1,23 +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(),
-});
-export type TDiscount = z.infer<typeof DiscountSchema>;