@jsdev_ninja/core 0.12.11 → 0.13.14

package/lib/entities/Discount/engine.ts

@@ -1,129 +1,138 @@
 import { TDiscount, AppliedDiscount, DiscountContext } from "./types";
 import { DiscountStrategyFactory } from "./factory";
 
+// discount engine - calculate discounts and return final prices
+// should register all discount types
+// should receive all store discounts
+// should check active discount that should be applied on cart
+// should find best discount per product
+// should apply discount to if stackable or best one
+// any applyd discount should mark products that effected and price before and after and average price per product in cart
+// should return items list with all calculations and final prices and discounts
+
 export class DiscountEngine {
-  static calculateDiscounts(
-    cart: Array<{
-      amount: number;
-      product: {
-        id: string;
-        price: number;
-      };
-    }>,
-    discounts: TDiscount[],
-    user?: Record<string, unknown>
-  ): {
-    items: Array<{
-      amount: number;
-      product: {
-        id: string;
-        price: number;
-      };
-      originalPrice: number;
-      finalPrice: number;
-      finalDiscount: number;
-      appliedDiscounts: string[];
-    }>;
-    totalDiscount: number;
-    appliedDiscounts: AppliedDiscount[];
-  } {
-    const context: DiscountContext = {
-      cart,
-      user,
-      appliedDiscounts: [],
-    };
-    
-    // Filter active discounts
-    const activeDiscounts = this.filterActiveDiscounts(discounts);
-    
-    // Apply discounts
-    const appliedDiscounts: AppliedDiscount[] = [];
-    
-    for (const discount of activeDiscounts) {
-      const strategy = DiscountStrategyFactory.getStrategy(discount);
-      if (!strategy) continue;
-      
-      // Check if discount can be applied
-      if (!strategy.canApply(discount, context)) continue;
-      
-      // Check if discount is stackable
-      if (!discount.conditions?.stackable && appliedDiscounts.length > 0) continue;
-      
-      // Calculate discount
-      const result = strategy.calculate(discount, context);
-      if (!result.applicable) continue;
-      
-      // Apply discount
-      appliedDiscounts.push({
-        discountId: discount.id,
-        discountName: discount.name[0]?.value || "Discount",
-        discountAmount: Number(result.discountAmount.toFixed(2)),
-        affectedItems: result.affectedItems,
-      });
-      
-      // Update context for next iteration
-      context.appliedDiscounts = appliedDiscounts;
-    }
-    
-    // Calculate final prices
-    const items = this.calculateFinalPrices(cart, appliedDiscounts);
-    
-    const totalDiscount = appliedDiscounts.reduce((sum, discount) => 
-      sum + discount.discountAmount, 0);
-    
-    return {
-      items,
-      totalDiscount: Number(totalDiscount.toFixed(2)),
-      appliedDiscounts,
-    };
-  }
-  
-  private static filterActiveDiscounts(discounts: TDiscount[]): TDiscount[] {
-    const now = Date.now();
-    return discounts.filter(discount => 
-      discount.active && 
-      discount.startDate <= now && 
-      discount.endDate >= now
-    );
-  }
-  
-  private static calculateFinalPrices(
-    cart: DiscountContext["cart"], 
-    appliedDiscounts: AppliedDiscount[]
-  ) {
-    return cart.map(item => {
-      const itemDiscounts = appliedDiscounts.filter(discount =>
-        discount.affectedItems.some(affected => affected.productId === item.product.id)
-      );
-      
-      const totalItemDiscount = itemDiscounts.reduce((sum, discount) => {
-        const affectedItem = discount.affectedItems.find(affected => 
-          affected.productId === item.product.id);
-        return sum + (affectedItem?.discountAmount || 0);
-      }, 0);
-      
-      const discountPerUnit = totalItemDiscount / item.amount;
-      const finalPrice = item.product.price - discountPerUnit;
-      
-      return {
-        amount: item.amount,
-        product: item.product,
-        originalPrice: Number(item.product.price.toFixed(2)),
-        finalPrice: Number(Math.max(0, finalPrice).toFixed(2)),
-        finalDiscount: Number(totalItemDiscount.toFixed(2)),
-        appliedDiscounts: itemDiscounts.map(d => d.discountId),
-      };
-    });
-  }
-  
-  static isDiscountActive(discount: TDiscount): boolean {
-    const now = Date.now();
-    return discount.active && 
-           discount.startDate <= now && 
-           discount.endDate >= now;
-  }
-  
-  static getActiveDiscounts(discounts: TDiscount[]): TDiscount[] {
-    return this.filterActiveDiscounts(discounts);
-  }
-} 
+	static calculateDiscounts(
+		cart: Array<{
+			amount: number;
+			product: {
+				id: string;
+				price: number;
+			};
+		}>,
+		discounts: TDiscount[],
+		user?: Record<string, unknown>
+	): {
+		items: Array<{
+			amount: number;
+			product: {
+				id: string;
+				price: number;
+			};
+			originalPrice: number;
+			finalPrice: number;
+			finalDiscount: number;
+			appliedDiscounts: string[];
+		}>;
+		totalDiscount: number;
+		appliedDiscounts: AppliedDiscount[];
+	} {
+		const context: DiscountContext = {
+			cart,
+			user,
+			appliedDiscounts: [],
+		};
+
+		// Filter active discounts
+		const activeDiscounts = this.filterActiveDiscounts(discounts);
+
+		// Apply discounts
+		const appliedDiscounts: AppliedDiscount[] = [];
+
+		for (const discount of activeDiscounts) {
+			const strategy = DiscountStrategyFactory.getStrategy(discount);
+			if (!strategy) continue;
+
+			// Check if discount can be applied
+			if (!strategy.canApply(discount, context)) continue;
+
+			// Check if discount is stackable
+			// todo
+			if (!discount.conditions?.stackable && appliedDiscounts.length > 0) continue;
+
+			// Calculate discount
+			const result = strategy.calculate(discount, context);
+			if (!result.applicable) continue;
+
+			// Apply discount
+			appliedDiscounts.push({
+				discountId: discount.id,
+				discountName: discount.name[0]?.value || "Discount",
+				discountAmount: Number(result.discountAmount.toFixed(2)),
+				affectedItems: result.affectedItems,
+			});
+
+			// Update context for next iteration
+			context.appliedDiscounts = appliedDiscounts;
+		}
+
+		// Calculate final prices
+		const items = this.calculateFinalPrices(cart, appliedDiscounts);
+
+		const totalDiscount = appliedDiscounts.reduce(
+			(sum, discount) => sum + discount.discountAmount,
+			0
+		);
+
+		return {
+			items,
+			totalDiscount: Number(totalDiscount.toFixed(2)),
+			appliedDiscounts,
+		};
+	}
+
+	private static filterActiveDiscounts(discounts: TDiscount[]): TDiscount[] {
+		const now = Date.now();
+		return discounts.filter(
+			(discount) => discount.active && discount.startDate <= now && discount.endDate >= now
+		);
+	}
+
+	private static calculateFinalPrices(
+		cart: DiscountContext["cart"],
+		appliedDiscounts: AppliedDiscount[]
+	) {
+		return cart.map((item) => {
+			const itemDiscounts = appliedDiscounts.filter((discount) =>
+				discount.affectedItems.some((affected) => affected.productId === item.product.id)
+			);
+
+			const totalItemDiscount = itemDiscounts.reduce((sum, discount) => {
+				const affectedItem = discount.affectedItems.find(
+					(affected) => affected.productId === item.product.id
+				);
+				return sum + (affectedItem?.discountAmount || 0);
+			}, 0);
+
+			const discountPerUnit = totalItemDiscount / item.amount;
+			const finalPrice = item.product.price - discountPerUnit;
+
+			return {
+				amount: item.amount,
+				product: item.product,
+				originalPrice: Number(item.product.price.toFixed(2)),
+				finalPrice: Number(Math.max(0, finalPrice).toFixed(2)),
+				finalDiscount: Number(totalItemDiscount.toFixed(2)),
+				appliedDiscounts: itemDiscounts.map((d) => d.discountId),
+			};
+		});
+	}
+
+	static isDiscountActive(discount: TDiscount): boolean {
+		const now = Date.now();
+		return discount.active && discount.startDate <= now && discount.endDate >= now;
+	}
+
+	static getActiveDiscounts(discounts: TDiscount[]): TDiscount[] {
+		return this.filterActiveDiscounts(discounts);
+	}
+}

package/lib/entities/Order.ts

@@ -34,6 +34,7 @@ export const OrderSchema = z.object({
 		cartDiscount: z.number(),
 		cartTotal: z.number(),
 		cartVat: z.number(),
+		deliveryPrice: z.number().optional(),
 	}),
 	originalAmount: z.number().positive().optional(), // what client pay
 	actualAmount: z.number().positive().optional(), // what store charge

package/lib/entities/Organization.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+// 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(),
+});
+
+export const NewOrganizationSchema = OrganizationSchema.omit({ id: true });
+
+export type TNewOrganization = z.infer<typeof NewOrganizationSchema>;
+export type TOrganization = z.infer<typeof OrganizationSchema>;

package/lib/entities/Profile.ts

@@ -23,6 +23,7 @@ export const ProfileSchema = z.object({
 	createdDate: z.number(),
 	lastActivityDate: z.number(),
 	paymentType: ProfilePaymentTypeSchema,
+	organizationId: z.string().optional(),
 });
 
 export type TProfile = z.infer<typeof ProfileSchema>;

package/lib/entities/index.ts

@@ -10,3 +10,5 @@ export * from "./Product";
 export * from "./Profile";
 export * from "./Store";
 export * from "./Discount";
+export * from "./Organization";
+export * from "./DeliveryNote";

package/lib/firebase-api/index.ts

@@ -14,6 +14,7 @@ export const storeCollections = {
 	payments: "payments",
 	settings: "settings",
 	discounts: "discounts",
+	organizations: "organizations",
 } as const;
 
 export const FirestoreApi = {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@jsdev_ninja/core",
-	"version": "0.12.11",
+	"version": "0.13.14",
 	"main": "dist/core.cjs.js",
 	"module": "dist/core.es.js",
 	"types": "dist/index.d.ts",