@jsdev_ninja/core 0.13.27 → 0.13.28

package/dist/lib/entities/Discount/strategies/__tests__/BundleStrategy.test.js

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { BundleDiscountStrategy } from "../BundleStrategy";
+describe("BundleDiscountStrategy", () => {
+    let strategy;
+    let mockContext;
+    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 = {
+                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",
+                    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 = {
+                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 = {
+                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 = {
+                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 = {
+                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 = {
+                cart: [
+                    {
+                        amount: 6, // 6 items
+                        product: {
+                            id: "product1",
+                            price: 10,
+                        },
+                    },
+                ],
+                user: undefined,
+                appliedDiscounts: [],
+            };
+            const discount = {
+                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",
+                    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 = {
+                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 = {
+    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/dist/lib/entities/Discount/strategy.d.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;
+}
+//# sourceMappingURL=strategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/strategy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAErE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IACjE,SAAS,CAAC,QAAQ,EAAE,SAAS,EAAE,OAAO,EAAE,eAAe,GAAG,cAAc,CAAC;CAC1E"}

package/dist/lib/entities/Discount/types.d.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+export declare const DiscountConditionsSchema: z.ZodOptional<z.ZodObject<{
+    minSpend: z.ZodOptional<z.ZodNumber>;
+    stackable: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    stackable: boolean;
+    minSpend?: number | undefined;
+}, {
+    minSpend?: number | undefined;
+    stackable?: boolean | undefined;
+}>>;
+export declare const DiscountVariantSchema: z.ZodDiscriminatedUnion<"variantType", [z.ZodObject<{
+    variantType: z.ZodLiteral<"bundle">;
+    productsId: z.ZodArray<z.ZodString, "many">;
+    requiredQuantity: z.ZodNumber;
+    bundlePrice: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    variantType: "bundle";
+    productsId: string[];
+    requiredQuantity: number;
+    bundlePrice: number;
+}, {
+    variantType: "bundle";
+    productsId: string[];
+    requiredQuantity: number;
+    bundlePrice: number;
+}>]>;
+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;
+    startDate: z.ZodNumber;
+    endDate: z.ZodNumber;
+    variant: z.ZodDiscriminatedUnion<"variantType", [z.ZodObject<{
+        variantType: z.ZodLiteral<"bundle">;
+        productsId: z.ZodArray<z.ZodString, "many">;
+        requiredQuantity: z.ZodNumber;
+        bundlePrice: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    }, {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    }>]>;
+    conditions: z.ZodOptional<z.ZodObject<{
+        minSpend: z.ZodOptional<z.ZodNumber>;
+        stackable: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        stackable: boolean;
+        minSpend?: number | undefined;
+    }, {
+        minSpend?: number | undefined;
+        stackable?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Discount";
+    id: string;
+    companyId: string;
+    storeId: string;
+    name: {
+        value: string;
+        lang: "he";
+    }[];
+    active: boolean;
+    startDate: number;
+    endDate: number;
+    variant: {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    };
+    conditions?: {
+        stackable: boolean;
+        minSpend?: number | undefined;
+    } | undefined;
+}, {
+    type: "Discount";
+    id: string;
+    companyId: string;
+    storeId: string;
+    name: {
+        value: string;
+        lang: "he";
+    }[];
+    active: boolean;
+    startDate: number;
+    endDate: number;
+    variant: {
+        variantType: "bundle";
+        productsId: string[];
+        requiredQuantity: number;
+        bundlePrice: number;
+    };
+    conditions?: {
+        minSpend?: number | undefined;
+        stackable?: boolean | undefined;
+    } | undefined;
+}>;
+export type TDiscount = z.infer<typeof DiscountSchema>;
+export type DiscountVariant = z.infer<typeof DiscountVariantSchema>;
+export type DiscountConditions = z.infer<typeof DiscountConditionsSchema>;
+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[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,wBAAwB;;;;;;;;;GAKzB,CAAC;AAGb,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;IAOhC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWzB,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACvD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAG1E,MAAM,WAAW,cAAc;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,KAAK,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,cAAc,CAAC,eAAe,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,KAAK,CAAC;QACX,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE;YACR,EAAE,EAAE,MAAM,CAAC;YACX,KAAK,EAAE,MAAM,CAAC;SACd,CAAC;KACF,CAAC,CAAC;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,gBAAgB,EAAE,eAAe,EAAE,CAAC;CACpC"}

package/dist/lib/entities/Discount/types.js

@@ -0,0 +1,29 @@
+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().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().nonempty() })),
+    active: z.boolean(),
+    startDate: z.number(),
+    endDate: z.number(),
+    variant: DiscountVariantSchema,
+    conditions: DiscountConditionsSchema,
+});

package/dist/lib/entities/Discount/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 declare function formatCurrency(value: number): number;
+/**
+ * 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 declare function formatCurrencyString(value: number): string;
+/**
+ * Ensures a monetary value is never negative
+ * @param value - The value to check
+ * @returns The value, or 0 if negative
+ */
+export declare function ensureNonNegative(value: number): number;
+/**
+ * Calculates the percentage discount
+ * @param originalPrice - The original price
+ * @param discountedPrice - The discounted price
+ * @returns The percentage discount (0-100)
+ */
+export declare function calculatePercentageDiscount(originalPrice: number, discountedPrice: number): number;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../lib/entities/Discount/utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAIlG"}

package/{lib/entities/Discount/utils.ts → dist/lib/entities/Discount/utils.js}

@@ -1,42 +1,39 @@
 /**
  * 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));
+export function formatCurrency(value) {
+    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);
+export function formatCurrencyString(value) {
+    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));
+export function ensureNonNegative(value) {
+    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);
-} 
+export function calculatePercentageDiscount(originalPrice, discountedPrice) {
+    if (originalPrice <= 0)
+        return 0;
+    const discount = originalPrice - discountedPrice;
+    return formatCurrency((discount / originalPrice) * 100);
+}

package/dist/lib/entities/FavoriteProduct.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const FavoriteProductSchema: z.ZodObject<{
+    type: z.ZodLiteral<"FavoriteProduct">;
+    id: z.ZodString;
+    companyId: z.ZodString;
+    storeId: z.ZodString;
+    userId: z.ZodString;
+    productId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "FavoriteProduct";
+    id: string;
+    companyId: string;
+    storeId: string;
+    userId: string;
+    productId: string;
+}, {
+    type: "FavoriteProduct";
+    id: string;
+    companyId: string;
+    storeId: string;
+    userId: string;
+    productId: string;
+}>;
+export type TFavoriteProduct = z.infer<typeof FavoriteProductSchema>;
+//# sourceMappingURL=FavoriteProduct.d.ts.map

package/dist/lib/entities/FavoriteProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FavoriteProduct.d.ts","sourceRoot":"","sources":["../../../lib/entities/FavoriteProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;EAOhC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/lib/entities/FavoriteProduct.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const FavoriteProductSchema = z.object({
+    type: z.literal("FavoriteProduct"),
+    id: z.string().uuid(),
+    companyId: z.string().uuid(),
+    storeId: z.string().uuid(),
+    userId: z.string().uuid(),
+    productId: z.string().uuid(),
+});