@jsdev_ninja/core 0.12.6 → 0.12.8

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

@@ -0,0 +1,295 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { BundleDiscountStrategy } from "../BundleStrategy";
+import { TDiscount, DiscountContext } from "../../types";
+
+describe("BundleDiscountStrategy", () => {
+  let strategy: BundleDiscountStrategy;
+  let mockContext: DiscountContext;
+  
+  beforeEach(() => {
+    strategy = new BundleDiscountStrategy();
+    
+    mockContext = {
+      cart: [
+        {
+          amount: 2,
+          product: {
+            id: "product1",
+            price: 10,
+          },
+        },
+        {
+          amount: 1,
+          product: {
+            id: "product2",
+            price: 15,
+          },
+        },
+      ],
+      user: undefined,
+      appliedDiscounts: [],
+    };
+  });
+  
+  describe("canApply", () => {
+    it("should return true for valid bundle 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", "product2"],
+          requiredQuantity: 3,
+          bundlePrice: 25,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      expect(strategy.canApply(discount, mockContext)).toBe(true);
+    });
+    
+    it("should return true for bundle variant type", () => {
+      const discount = {
+        ...mockDiscount,
+        variant: {
+          variantType: "bundle" as const,
+          productsId: ["product1", "product2"],
+          requiredQuantity: 3,
+          bundlePrice: 25,
+        },
+      };
+      
+      // 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", () => {
+      const discount: TDiscount = {
+        type: "Discount",
+        storeId: "store1",
+        companyId: "company1",
+        id: "bundle1",
+        name: [{ lang: "he", value: "Buy 5 for $40" }],
+        active: true,
+        startDate: Date.now() - 1000,
+        endDate: Date.now() + 1000,
+        variant: {
+          variantType: "bundle",
+          productsId: ["product1", "product2"],
+          requiredQuantity: 5, // Need 5, but cart only has 3
+          bundlePrice: 40,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      expect(strategy.canApply(discount, mockContext)).toBe(false);
+    });
+    
+    it("should return false when discount is inactive", () => {
+      const discount: 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", "product2"],
+          requiredQuantity: 3,
+          bundlePrice: 25,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      expect(strategy.canApply(discount, mockContext)).toBe(false);
+    });
+    
+    it("should return false when discount is expired", () => {
+      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", "product2"],
+          requiredQuantity: 3,
+          bundlePrice: 25,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      expect(strategy.canApply(discount, mockContext)).toBe(false);
+    });
+  });
+  
+  describe("calculate", () => {
+    it("should calculate bundle discount correctly", () => {
+      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", "product2"],
+          requiredQuantity: 3,
+          bundlePrice: 25,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      const result = strategy.calculate(discount, mockContext);
+      
+      expect(result.applicable).toBe(true);
+      expect(result.discountAmount).toBe(10); // (2×10 + 1×15) - 25 = 35 - 25 = 10
+      expect(result.affectedItems).toHaveLength(2);
+      
+      // Check product1 discount
+      const product1Item = result.affectedItems.find(item => item.productId === "product1");
+      expect(product1Item).toBeDefined();
+      expect(product1Item!.discountAmount).toBeCloseTo(5.71, 2); // Proportional to 20/35
+      
+      // Check product2 discount
+      const product2Item = result.affectedItems.find(item => item.productId === "product2");
+      expect(product2Item).toBeDefined();
+      expect(product2Item!.discountAmount).toBeCloseTo(4.29, 2); // Proportional to 15/35
+    });
+    
+    it("should handle multiple bundles", () => {
+      const contextWithMoreItems: DiscountContext = {
+        cart: [
+          {
+            amount: 6, // 6 items
+            product: {
+              id: "product1",
+              price: 10,
+            },
+          },
+        ],
+        user: undefined,
+        appliedDiscounts: [],
+      };
+      
+      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,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      const result = strategy.calculate(discount, contextWithMoreItems);
+      
+      expect(result.applicable).toBe(true);
+      expect(result.discountAmount).toBe(10); // (6×10) - (2×25) = 60 - 50 = 10
+      expect(result.affectedItems).toHaveLength(1);
+      expect(result.affectedItems[0].discountAmount).toBe(10);
+    });
+    
+    it("should return not applicable for invalid bundle", () => {
+      const discount = {
+        ...mockDiscount,
+        variant: {
+          variantType: "bundle" as const,
+          productsId: ["product1"],
+          requiredQuantity: 10, // Too many required
+          bundlePrice: 25,
+        },
+      };
+      
+      const result = strategy.calculate(discount, mockContext);
+      
+      expect(result.applicable).toBe(false);
+      expect(result.discountAmount).toBe(0);
+      expect(result.affectedItems).toHaveLength(0);
+    });
+    
+    it("should return not applicable when not enough items", () => {
+      const discount: TDiscount = {
+        type: "Discount",
+        storeId: "store1",
+        companyId: "company1",
+        id: "bundle1",
+        name: [{ lang: "he", value: "Buy 5 for $40" }],
+        active: true,
+        startDate: Date.now() - 1000,
+        endDate: Date.now() + 1000,
+        variant: {
+          variantType: "bundle",
+          productsId: ["product1", "product2"],
+          requiredQuantity: 5,
+          bundlePrice: 40,
+        },
+        conditions: {
+          stackable: false,
+        },
+      };
+      
+      const result = strategy.calculate(discount, mockContext);
+      
+      expect(result.applicable).toBe(false);
+      expect(result.discountAmount).toBe(0);
+      expect(result.affectedItems).toHaveLength(0);
+    });
+  });
+});
+
+const mockDiscount: 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,
+  },
+}; 

package/lib/entities/Discount/strategy.ts

@@ -0,0 +1,6 @@
+import { TDiscount, DiscountResult, DiscountContext } from "./types";
+
+export interface DiscountStrategy {
+  canApply(discount: TDiscount, context: DiscountContext): boolean;
+  calculate(discount: TDiscount, context: DiscountContext): DiscountResult;
+} 

package/lib/entities/Discount/types.ts

@@ -0,0 +1,68 @@
+import { z } from "zod";
+
+// Simple discount conditions
+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)
+  }),
+]);
+
+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,
+});
+
+export type TDiscount = z.infer<typeof DiscountSchema>;
+export type DiscountVariant = z.infer<typeof DiscountVariantSchema>;
+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;
+  }>;
+}
+
+export interface AppliedDiscount {
+  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[];
+}
+
+ 

package/lib/entities/Discount/utils.ts

@@ -0,0 +1,42 @@
+/**
+ * Utility functions for discount calculations
+ */
+
+/**
+ * Formats a number to 2 decimal places and returns as a number
+ * @param value - The number to format
+ * @returns The formatted number with 2 decimal places
+ */
+export function formatCurrency(value: number): number {
+  return Number(value.toFixed(2));
+}
+
+/**
+ * Formats a number to 2 decimal places and returns as a string
+ * @param value - The number to format
+ * @returns The formatted string with 2 decimal places
+ */
+export function formatCurrencyString(value: number): string {
+  return value.toFixed(2);
+}
+
+/**
+ * Ensures a monetary value is never negative
+ * @param value - The value to check
+ * @returns The value, or 0 if negative
+ */
+export function ensureNonNegative(value: number): number {
+  return Math.max(0, formatCurrency(value));
+}
+
+/**
+ * Calculates the percentage discount
+ * @param originalPrice - The original price
+ * @param discountedPrice - The discounted price
+ * @returns The percentage discount (0-100)
+ */
+export function calculatePercentageDiscount(originalPrice: number, discountedPrice: number): number {
+  if (originalPrice <= 0) return 0;
+  const discount = originalPrice - discountedPrice;
+  return formatCurrency((discount / originalPrice) * 100);
+} 

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.6",
+	"version": "0.12.8",
 	"main": "dist/core.cjs.js",
 	"module": "dist/core.es.js",
 	"types": "dist/index.d.ts",
@@ -12,15 +12,16 @@
 		"build": "vite build && tsc -b",
 		"lint": "eslint .",
 		"preview": "vite preview",
-		"publish_core": "yarn publish --non-interactive"
+		"publish_core": "yarn publish --non-interactive",
+		"test": "vitest",
+		"test:run": "vitest run"
 	},
 	"dependencies": {
 		"zod": "^3.23.8"
 	},
 	"devDependencies": {
-		"react": "^18.3.1",
-		"react-dom": "^18.3.1",
 		"@eslint/js": "^9.9.0",
+		"@types/node": "^24.0.15",
 		"@types/react": "^18.3.3",
 		"@types/react-dom": "^18.3.0",
 		"@vitejs/plugin-react-swc": "^3.5.0",
@@ -28,8 +29,12 @@
 		"eslint-plugin-react-hooks": "^5.1.0-rc.0",
 		"eslint-plugin-react-refresh": "^0.4.9",
 		"globals": "^15.9.0",
+		"react": "^18.3.1",
+		"react-dom": "^18.3.1",
+		"ts-node": "^10.9.2",
 		"typescript": "^5.5.3",
 		"typescript-eslint": "^8.0.1",
-		"vite": "^5.4.1"
+		"vite": "^5.4.1",
+		"vitest": "^3.2.4"
 	}
 }

package/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['**/__tests__/**/*.test.ts', '**/*.test.ts'],
+    exclude: ['node_modules', 'dist'],
+  },
+}); 

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(),
-});