@jsdev_ninja/core 0.13.26 → 0.13.28

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

@@ -1,295 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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,
-});
-
-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

@@ -1,42 +0,0 @@
-/**
- * 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/entities/FavoriteProduct.ts

@@ -1,12 +0,0 @@
-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(),
-});
-
-export type TFavoriteProduct = z.infer<typeof FavoriteProductSchema>;

package/lib/entities/Invoice.ts

@@ -1,57 +0,0 @@
-import { z } from "zod";
-import { CalculatedDataSchema } from "./DeliveryNote";
-
-// Main Invoice schema
-export const EzInvoiceSchema = 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 InvoiceSchema = z.object({
-	id: z.string().min(1, "ID is required"),
-	number: z.string().min(1, "Number is required"),
-	date: z.string().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 TInvoice = z.infer<typeof InvoiceSchema>;
-export type TEzInvoice = z.infer<typeof EzInvoiceSchema>;

package/lib/entities/Locale.ts

@@ -1,8 +0,0 @@
-import { z } from "zod";
-
-export const LocaleSchema = z.object({
-	lang: z.enum(["he"]),
-	value: z.string(),
-});
-
-export const LocaleValueSchema = z.array(LocaleSchema);

package/lib/entities/Order.ts

@@ -1,66 +0,0 @@
-import { z } from "zod";
-import { ProfileSchema } from "./Profile";
-import { notEmptyTextSchema } from "./Atoms";
-import { CartItemProductSchema } from "./Cart";
-import { DeliveryNoteSchema, EzDeliveryNoteSchema } from "./DeliveryNote";
-import { BillingAccountSchema } from "./Organization";
-import { EzInvoiceSchema, InvoiceSchema } from "./Invoice";
-
-// pending - order created / by user
-// processing order accepted by store by admin
-// delivered - order delivered by admin
-// canceled - order canceled by user/admin
-// completed - order paid by admin
-
-// type PaymentMethod = "credit_card" | "paypal" | "bank_transfer" | "cash_on_delivery";
-
-export const OrderSchema = z.object({
-	type: z.literal("Order"),
-	id: notEmptyTextSchema,
-	companyId: notEmptyTextSchema,
-	storeId: notEmptyTextSchema,
-	userId: notEmptyTextSchema,
-	status: z.enum([
-		"draft", // before payment
-		"pending", // after payment
-		"processing", // after admin approve
-		"in_delivery", //
-		"delivered",
-		"cancelled",
-		"completed",
-		"refunded",
-	]),
-	paymentType: z.enum(["internal", "external"]).optional(),
-	paymentStatus: z.enum(["pending", "pending_j5", "external", "completed", "failed", "refunded"]), //todo check if hyp support partial refund
-	cart: z.object({
-		id: z.string(),
-		items: z.array(CartItemProductSchema),
-		cartDiscount: z.number(),
-		cartTotal: z.number(),
-		cartVat: z.number(),
-		deliveryPrice: z.number().optional(), // final delivery price for cart
-	}),
-	storeOptions: z
-		.object({
-			deliveryPrice: z.number().optional(),
-			freeDeliveryPrice: z.number().optional(),
-			isVatIncludedInPrice: z.boolean().optional(),
-		})
-		.optional(),
-	orderDeliveryPrice: z.number().optional(), // delivery price for order
-	originalAmount: z.number().positive().optional(), // what client pay
-	actualAmount: z.number().positive().optional(), // what store charge
-	date: z.number(),
-	deliveryDate: z.coerce.number(),
-	client: ProfileSchema.required({}),
-	nameOnInvoice: z.string().optional(),
-	clientComment: z.string().optional(),
-	organizationId: z.string().optional(),
-	billingAccount: BillingAccountSchema.optional(),
-	deliveryNote: DeliveryNoteSchema.optional(),
-	invoice: InvoiceSchema.optional(),
-	ezInvoice: EzInvoiceSchema.optional(),
-	ezDeliveryNote: EzDeliveryNoteSchema.optional(),
-});
-
-export type TOrder = z.infer<typeof OrderSchema>;

package/lib/entities/Organization.ts

@@ -1,23 +0,0 @@
-import { z } from "zod";
-
-export const BillingAccountSchema = z.object({
-	number: z.string(),
-	name: z.string(),
-	id: z.string(),
-});
-
-// client organization for clients
-export const OrganizationSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	discountPercentage: z.number().positive().min(0).max(100).optional(),
-	nameOnInvoice: z.string().optional(),
-	billingAccounts: z.array(BillingAccountSchema),
-	paymentType: z.enum(["default", "delayed"]),
-});
-
-export const NewOrganizationSchema = OrganizationSchema.omit({ id: true });
-
-export type TBillingAccount = z.infer<typeof BillingAccountSchema>;
-export type TNewOrganization = z.infer<typeof NewOrganizationSchema>;
-export type TOrganization = z.infer<typeof OrganizationSchema>;

package/lib/entities/Product.ts

@@ -1,68 +0,0 @@
-import { z } from "zod";
-import { LocaleSchema } from "./Locale";
-import { CategorySchema } from "./Category";
-
-const text = z.string().min(1);
-
-export const ProductSchema = z.object({
-	type: z.literal("Product"),
-	storeId: text,
-	companyId: text,
-	id: text,
-	objectID: text,
-	sku: text,
-	name: z.array(LocaleSchema),
-	description: z.array(LocaleSchema),
-	isPublished: z.boolean(),
-	vat: z.boolean(),
-	priceType: z.object({
-		type: z.enum(["unit", "kg", "gram", "liter", "ml"]),
-		value: z.number(),
-	}),
-	price: z.number().positive(),
-	purchasePrice: z.number().optional(),
-	profitPercentage: z.number().optional(),
-	currency: z.literal("ILS"),
-	discount: z.object({
-		type: z.enum(["number", "percent", "none"]),
-		value: z.number(),
-	}),
-	isDiscountable: z.boolean({ description: "included in store discounts" }).optional(),
-	weight: z.object({
-		value: z.number(),
-		unit: z.enum(["kg", "gram", "none"]),
-	}),
-	volume: z.object({
-		value: z.number(),
-		unit: z.enum(["liter", "ml", "none"]),
-	}),
-	images: z.array(z.object({ url: z.string().url(), id: z.string() })),
-	manufacturer: z.string(),
-	brand: z.string(),
-	importer: z.string(),
-	supplier: z.string(),
-	ingredients: z.array(LocaleSchema),
-	created_at: z.number(),
-	updated_at: z.number(),
-	categoryIds: z.array(z.string().nonempty()),
-
-	// @deprecated
-	categoryList: z.array(CategorySchema).optional(),
-	// @deprecated
-	categories: z.object({
-		lvl0: z.array(z.string()),
-		lvl1: z.array(z.string()),
-		lvl2: z.array(z.string()),
-		lvl3: z.array(z.string()),
-		lvl4: z.array(z.string()),
-	}).optional(),
-	// @deprecated
-	categoryNames: z.array(z.string()).optional(),
-});
-export type TProduct = z.infer<typeof ProductSchema>;
-
-export const NewProductSchema = ProductSchema.extend({
-	image: z.instanceof(File).optional(),
-});
-
-export type TNewProduct = z.infer<typeof NewProductSchema>;