@jsdev_ninja/core 0.13.26 → 0.13.28

package/lib/entities/Cart.ts

@@ -1,24 +0,0 @@
-import { z } from "zod";
-import { ProductSchema } from "./Product";
-
-export const CartItemProductSchema = z.object({
-	product: ProductSchema,
-	originalPrice: z.number().optional(),
-	finalPrice: z.number().optional(),
-	finalDiscount: z.number().optional(),
-	amount: z.number().positive({ message: "Quantity must be a positive number." }),
-});
-
-export type TCartItemProduct = z.infer<typeof CartItemProductSchema>;
-
-export const CartSchema = z.object({
-	type: z.literal("Cart"),
-	id: z.string().uuid(),
-	companyId: z.string().uuid(),
-	storeId: z.string().uuid(),
-	userId: z.string().uuid(),
-	status: z.enum(["active", "draft", "completed"]),
-	items: z.array(CartItemProductSchema),
-});
-
-export type TCart = z.infer<typeof CartSchema>;

package/lib/entities/Category.ts

@@ -1,35 +0,0 @@
-import { z } from "zod";
-import { LocaleSchema } from "./Locale";
-
-export const BaseCategorySchema = z.object({
-	id: z.string().min(1),
-	companyId: z.string().min(1),
-	storeId: z.string().min(1),
-	parentId: z.string().nullish(),
-	tag: z.string().optional(),
-	locales: z.array(LocaleSchema),
-	depth: z.number(),
-});
-
-type Category = z.infer<typeof BaseCategorySchema> & {
-	children: Category[];
-};
-
-export const CategorySchema: z.ZodType<Category> = BaseCategorySchema.extend({
-	children: z.lazy(() => CategorySchema.array()),
-});
-
-// export type TCategory = z.infer<typeof CategorySchema>;
-export type TCategory = z.infer<typeof BaseCategorySchema> & {
-	children: TCategory[];
-};
-export const TFlattenCategorySchema = BaseCategorySchema.extend({
-	index: z.number(),
-	depth: z.number(),
-	collapsed: z.boolean().optional(),
-	children: z.array(CategorySchema),
-});
-
-export type TFlattenCategory = z.infer<typeof TFlattenCategorySchema>;
-
-export type TNewCategory = Omit<TCategory, "id">;

package/lib/entities/Company.ts

@@ -1,9 +0,0 @@
-import { z } from "zod";
-
-export const CompanySchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	websiteDomains: z.array(z.string()),
-});
-
-export type TCompany = z.infer<typeof CompanySchema>;

package/lib/entities/DeliveryNote.ts

@@ -1,70 +0,0 @@
-import { z } from "zod";
-
-// Schema for the calculated data section
-export const CalculatedDataSchema = z.object({
-	_COMMENT: z.string().optional(),
-	transaction_id: z.string(),
-	date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format"),
-	currency: z.string().length(3, "Currency must be 3 characters"),
-	rate: z.number().positive(),
-	vat: z.string().regex(/^\d+\.\d{2}$/, "VAT must be in format XX.XX"),
-	vat_price: z.number().positive(),
-	price_discount: z.number(),
-	price_discount_in_currency: z.number(),
-	price_total: z.string().regex(/^\d+\.\d{2}$/, "Price total must be in format XX.XX"),
-	price_total_in_currency: z.number().positive(),
-});
-
-export const EzDeliveryNoteSchema = z.object({
-	doc_uuid: z.string().uuid("Document UUID must be a valid UUID"),
-	pdf_link: z.string().url("PDF link must be a valid URL"),
-	pdf_link_copy: z.string().url("PDF copy link must be a valid URL"),
-	doc_number: z.string().min(1, "Document number is required"),
-	sent_mails: z.array(z.string().email("Each email must be valid")),
-	success: z.boolean(),
-	ua_uuid: z.string().uuid("UA UUID must be a valid UUID"),
-	calculatedData: CalculatedDataSchema,
-	warning: z.string().optional(),
-	date: z.number().optional(),
-});
-
-export const DeliveryNoteSchema = z.object({
-	id: z.string().min(1, "ID is required"),
-	number: z.string().min(1, "Number is required"),
-	date: z.number().min(1, "Date is required"),
-	createdAt: z.number().min(1, "Created at is required"),
-	status: z.enum(["pending", "paid", "cancelled"]),
-	companyDetails: z
-		.object({
-			name: z.string().min(1, "Name is required").optional(),
-			address: z.string().min(1, "Address is required").optional(),
-			phone: z.string().min(1, "Phone is required").optional(),
-			email: z.string().email("Email must be valid").optional(),
-		})
-		.optional(),
-	clientDetails: z
-		.object({
-			name: z.string().min(1, "Name is required").optional(),
-			address: z.string().min(1, "Address is required").optional(),
-			phone: z.string().min(1, "Phone is required").optional(),
-			email: z.string().email("Email must be valid").optional(),
-		})
-		.optional(),
-	items: z
-		.array(
-			z.object({
-				name: z.string().min(1, "Name is required").optional(),
-				price: z.number().min(1, "Price is required").optional(),
-				quantity: z.number().min(1, "Quantity is required").optional(),
-				total: z.number().min(1, "Total is required").optional(),
-			})
-		)
-		.optional(),
-	total: z.number().min(1, "Total is required").optional(),
-	vat: z.number().min(1, "VAT is required").optional(),
-	link: z.string().url("Link must be a valid URL").optional(),
-});
-// Type inference
-export type TEzDeliveryNote = z.infer<typeof EzDeliveryNoteSchema>;
-export type TDeliveryNote = z.infer<typeof DeliveryNoteSchema>;
-export type TCalculatedData = z.infer<typeof CalculatedDataSchema>;

package/lib/entities/Discount/__tests__/engine.test.ts

@@ -1,337 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { DiscountEngine } from "../engine";
-import { DiscountStrategyFactory } from "../factory";
-import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
-import { TDiscount } from "../types";
-
-describe("DiscountEngine", () => {
-  beforeEach(() => {
-    DiscountStrategyFactory.clearStrategies();
-    DiscountStrategyFactory.registerStrategy("bundle", new BundleDiscountStrategy());
-  });
-  
-  afterEach(() => {
-    DiscountStrategyFactory.clearStrategies();
-  });
-  
-  describe("calculateDiscounts", () => {
-    it("should apply bundle discount correctly", () => {
-      const cart = [
-        {
-          amount: 2,
-          product: {
-            id: "product1",
-            price: 10,
-          },
-        },
-        {
-          amount: 1,
-          product: {
-            id: "product2",
-            price: 15,
-          },
-        },
-      ];
-      
-      const discounts: 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 = DiscountEngine.calculateDiscounts(cart, discounts);
-      
-      expect(result.totalDiscount).toBe(10);
-      expect(result.appliedDiscounts).toHaveLength(1);
-      expect(result.appliedDiscounts[0].discountId).toBe("bundle1");
-      expect(result.items).toHaveLength(2);
-      
-      // Check final prices
-      const product1Item = result.items.find(item => item.product.id === "product1");
-      expect(product1Item?.finalPrice).toBeCloseTo(7.14, 2); // 10 - (5.71/2) = 7.145
-      
-      const product2Item = result.items.find(item => item.product.id === "product2");
-      expect(product2Item?.finalPrice).toBeCloseTo(10.71, 2); // 15 - 4.29 = 10.71
-    });
-    
-    it("should handle multiple discounts", () => {
-      const cart = [
-        {
-          amount: 4,
-          product: {
-            id: "product1",
-            price: 10,
-          },
-        },
-      ];
-      
-      const discounts: 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: true, // Allow stacking
-          },
-        },
-        {
-          type: "Discount",
-          storeId: "store1",
-          companyId: "company1",
-          id: "bundle2",
-          name: [{ lang: "he", value: "Buy 2 for $15" }],
-          active: true,
-          startDate: Date.now() - 1000,
-          endDate: Date.now() + 1000,
-          variant: {
-            variantType: "bundle",
-            productsId: ["product1"],
-            requiredQuantity: 2,
-            bundlePrice: 15,
-          },
-          conditions: {
-            stackable: true,
-          },
-        },
-      ];
-      
-      const result = DiscountEngine.calculateDiscounts(cart, discounts);
-      
-      expect(result.appliedDiscounts).toHaveLength(2);
-      expect(result.totalDiscount).toBeGreaterThan(0);
-    });
-    
-    it("should filter out inactive discounts", () => {
-      const cart = [
-        {
-          amount: 3,
-          product: {
-            id: "product1",
-            price: 10,
-          },
-        },
-      ];
-      
-      const discounts: 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"],
-            requiredQuantity: 3,
-            bundlePrice: 25,
-          },
-          conditions: {
-            stackable: false,
-          },
-        },
-      ];
-      
-      const result = DiscountEngine.calculateDiscounts(cart, discounts);
-      
-      expect(result.totalDiscount).toBe(0);
-      expect(result.appliedDiscounts).toHaveLength(0);
-    });
-    
-    it("should handle empty cart", () => {
-      const cart: Array<{
-        amount: number;
-        product: {
-          id: string;
-          price: number;
-        };
-      }> = [];
-      const discounts: 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 = DiscountEngine.calculateDiscounts(cart, discounts);
-      
-      expect(result.totalDiscount).toBe(0);
-      expect(result.appliedDiscounts).toHaveLength(0);
-      expect(result.items).toHaveLength(0);
-    });
-    
-    it("should handle empty discounts", () => {
-      const cart = [
-        {
-          amount: 2,
-          product: {
-            id: "product1",
-            price: 10,
-          },
-        },
-      ];
-      
-      const discounts: TDiscount[] = [];
-      
-      const result = DiscountEngine.calculateDiscounts(cart, discounts);
-      
-      expect(result.totalDiscount).toBe(0);
-      expect(result.appliedDiscounts).toHaveLength(0);
-      expect(result.items).toHaveLength(1);
-      expect(result.items[0].finalPrice).toBe(10); // No discount applied
-    });
-  });
-  
-  describe("isDiscountActive", () => {
-    it("should return true for active 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"],
-          requiredQuantity: 3,
-          bundlePrice: 25,
-        },
-      };
-      
-      expect(DiscountEngine.isDiscountActive(discount)).toBe(true);
-    });
-    
-    it("should return false for inactive discount", () => {
-      const discount: TDiscount = {
-        type: "Discount",
-        storeId: "store1",
-        companyId: "company1",
-        id: "bundle1",
-        name: [{ lang: "he", value: "Buy 3 for $25" }],
-        active: false,
-        startDate: Date.now() - 1000,
-        endDate: Date.now() + 1000,
-        variant: {
-          variantType: "bundle",
-          productsId: ["product1"],
-          requiredQuantity: 3,
-          bundlePrice: 25,
-        },
-      };
-      
-      expect(DiscountEngine.isDiscountActive(discount)).toBe(false);
-    });
-    
-    it("should return false for expired 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() - 2000,
-        endDate: Date.now() - 1000, // Expired
-        variant: {
-          variantType: "bundle",
-          productsId: ["product1"],
-          requiredQuantity: 3,
-          bundlePrice: 25,
-        },
-      };
-      
-      expect(DiscountEngine.isDiscountActive(discount)).toBe(false);
-    });
-  });
-  
-  describe("getActiveDiscounts", () => {
-    it("should filter active discounts", () => {
-      const discounts: TDiscount[] = [
-        {
-          type: "Discount",
-          storeId: "store1",
-          companyId: "company1",
-          id: "active1",
-          name: [{ lang: "he", value: "Active Discount" }],
-          active: true,
-          startDate: Date.now() - 1000,
-          endDate: Date.now() + 1000,
-          variant: {
-            variantType: "bundle",
-            productsId: ["product1"],
-            requiredQuantity: 3,
-            bundlePrice: 25,
-          },
-        },
-        {
-          type: "Discount",
-          storeId: "store1",
-          companyId: "company1",
-          id: "inactive1",
-          name: [{ lang: "he", value: "Inactive Discount" }],
-          active: false,
-          startDate: Date.now() - 1000,
-          endDate: Date.now() + 1000,
-          variant: {
-            variantType: "bundle",
-            productsId: ["product1"],
-            requiredQuantity: 3,
-            bundlePrice: 25,
-          },
-        },
-      ];
-      
-      const activeDiscounts = DiscountEngine.getActiveDiscounts(discounts);
-      
-      expect(activeDiscounts).toHaveLength(1);
-      expect(activeDiscounts[0].id).toBe("active1");
-    });
-  });
-}); 

package/lib/entities/Discount/__tests__/factory.test.ts

@@ -1,91 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { DiscountStrategyFactory } from "../factory";
-import { DiscountStrategy } from "../strategy";
-import { TDiscount } from "../types";
-
-describe("DiscountStrategyFactory", () => {
-  beforeEach(() => {
-    DiscountStrategyFactory.clearStrategies();
-  });
-  
-  afterEach(() => {
-    DiscountStrategyFactory.clearStrategies();
-  });
-  
-  it("should register and get strategy", () => {
-    const mockStrategy: DiscountStrategy = {
-      canApply: () => false,
-      calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
-    };
-    
-    DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
-    
-    const discount: TDiscount = {
-      type: "Discount",
-      storeId: "store1",
-      companyId: "company1",
-      id: "test1",
-      name: [{ lang: "he", value: "Test Discount" }],
-      active: true,
-      startDate: Date.now() - 1000,
-      endDate: Date.now() + 1000,
-      variant: {
-        variantType: "bundle",
-        productsId: ["product1"],
-        requiredQuantity: 3,
-        bundlePrice: 25,
-      },
-    };
-    
-    const result = DiscountStrategyFactory.getStrategy(discount);
-    expect(result).toBe(mockStrategy);
-  });
-  
-  it("should return null for unregistered strategy", () => {
-    const discount: TDiscount = {
-      type: "Discount",
-      storeId: "store1",
-      companyId: "company1",
-      id: "test1",
-      name: [{ lang: "he", value: "Test Discount" }],
-      active: true,
-      startDate: Date.now() - 1000,
-      endDate: Date.now() + 1000,
-      variant: {
-        variantType: "bundle",
-        productsId: ["product1"],
-        requiredQuantity: 3,
-        bundlePrice: 25,
-      },
-    };
-    
-    const result = DiscountStrategyFactory.getStrategy(discount);
-    expect(result).toBeNull();
-  });
-  
-  it("should get registered types", () => {
-    const mockStrategy: DiscountStrategy = {
-      canApply: () => false,
-      calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
-    };
-    
-    DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
-    DiscountStrategyFactory.registerStrategy("percentage", mockStrategy);
-    
-    const types = DiscountStrategyFactory.getRegisteredTypes();
-    expect(types).toEqual(["bundle", "percentage"]);
-  });
-  
-  it("should clear strategies", () => {
-    const mockStrategy: DiscountStrategy = {
-      canApply: () => false,
-      calculate: () => ({ applicable: false, discountAmount: 0, affectedItems: [] }),
-    };
-    
-    DiscountStrategyFactory.registerStrategy("bundle", mockStrategy);
-    expect(DiscountStrategyFactory.getRegisteredTypes()).toHaveLength(1);
-    
-    DiscountStrategyFactory.clearStrategies();
-    expect(DiscountStrategyFactory.getRegisteredTypes()).toHaveLength(0);
-  });
-}); 

package/lib/entities/Discount/__tests__/integration.test.ts

@@ -1,132 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { DiscountEngine } from "../engine";
-import { DiscountStrategyFactory } from "../factory";
-import { BundleDiscountStrategy } from "../strategies/BundleStrategy";
-import { TDiscount } from "../types";
-
-describe("Discount System Integration", () => {
-  beforeEach(() => {
-    DiscountStrategyFactory.clearStrategies();
-    DiscountStrategyFactory.registerStrategy("bundle", new BundleDiscountStrategy());
-  });
-  
-  afterEach(() => {
-    DiscountStrategyFactory.clearStrategies();
-  });
-  
-  it("should handle real-world bundle scenario", () => {
-    // Scenario: Buy 3 dairy products for $20
-    const cart = [
-      {
-        amount: 2, // 2 milk
-        product: {
-          id: "milk",
-          price: 8, // $8 each
-        },
-      },
-      {
-        amount: 1, // 1 yogurt
-        product: {
-          id: "yogurt",
-          price: 6, // $6 each
-        },
-      },
-      {
-        amount: 1, // 1 bread (not in bundle)
-        product: {
-          id: "bread",
-          price: 4, // $4 each
-        },
-      },
-    ];
-    
-    const dairyBundle: TDiscount = {
-      type: "Discount",
-      storeId: "store1",
-      companyId: "company1",
-      id: "dairy-bundle",
-      name: [{ lang: "he", value: "3 Dairy Products for $20" }],
-      active: true,
-      startDate: Date.now() - 1000,
-      endDate: Date.now() + 1000,
-      variant: {
-        variantType: "bundle",
-        productsId: ["milk", "yogurt", "cheese"], // Dairy products
-        requiredQuantity: 3,
-        bundlePrice: 20,
-      },
-      conditions: {
-        stackable: false,
-      },
-    };
-    
-    const result = DiscountEngine.calculateDiscounts(cart, [dairyBundle]);
-    
-    // Original prices:
-    // milk: 2 × $8 = $16
-    // yogurt: 1 × $6 = $6
-    // bread: 1 × $4 = $4
-    // Total: $26
-    
-    // Bundle applies to milk + yogurt (3 items for $20)
-    // Remaining: bread at $4
-    // New total: $24
-    
-    expect(result.totalDiscount).toBe(2); // $26 - $24
-    expect(result.appliedDiscounts).toHaveLength(1);
-    expect(result.appliedDiscounts[0].discountId).toBe("dairy-bundle");
-    
-    // Check individual item prices
-    const milkItem = result.items.find(item => item.product.id === "milk");
-    expect(milkItem?.finalPrice).toBeCloseTo(7.28, 2); // 8 - (1.45/2) = 7.275
-    
-    const yogurtItem = result.items.find(item => item.product.id === "yogurt");
-    expect(yogurtItem?.finalPrice).toBeCloseTo(5.45, 2); // 6 - 0.55 = 5.45
-    
-    const breadItem = result.items.find(item => item.product.id === "bread");
-    expect(breadItem?.finalPrice).toBe(4); // No discount
-  });
-  
-  it("should handle BOGO scenario", () => {
-    // Scenario: Buy 2 Get 1 Free
-    const cart = [
-      {
-        amount: 3, // Buy 3 items
-        product: {
-          id: "product1",
-          price: 10, // $10 each
-        },
-      },
-    ];
-    
-    const bogoDiscount: TDiscount = {
-      type: "Discount",
-      storeId: "store1",
-      companyId: "company1",
-      id: "bogo",
-      name: [{ lang: "he", value: "Buy 2 Get 1 Free" }],
-      active: true,
-      startDate: Date.now() - 1000,
-      endDate: Date.now() + 1000,
-      variant: {
-        variantType: "bundle",
-        productsId: ["product1"],
-        requiredQuantity: 3, // Buy 2 + get 1 free = 3 items
-        bundlePrice: 20, // Price of 2 items (10 × 2)
-      },
-      conditions: {
-        stackable: false,
-      },
-    };
-    
-    const result = DiscountEngine.calculateDiscounts(cart, [bogoDiscount]);
-    
-    // Original: 3 × $10 = $30
-    // Bundle: 3 items for $20
-    // Discount: $10
-    
-    expect(result.totalDiscount).toBe(10);
-    expect(result.appliedDiscounts).toHaveLength(1);
-    expect(result.items[0].finalPrice).toBeCloseTo(6.67, 2); // $20 / 3
-  });
-});