@jsdev_ninja/core 0.12.6 → 0.12.7

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

@@ -0,0 +1,290 @@
+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 false for wrong variant type", () => {
+      const discount = {
+        ...mockDiscount,
+        variant: {
+          variantType: "percentage" as any,
+          percentage: 20,
+        },
+      };
+      
+      expect(strategy.canApply(discount, mockContext)).toBe(false);
+    });
+    
+    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 wrong variant type", () => {
+      const discount = {
+        ...mockDiscount,
+        variant: {
+          variantType: "percentage" as any,
+          percentage: 20,
+        },
+      };
+      
+      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/package.json

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