feat(): added percentage calculations for all cases (#6300)

what:

- adds missing percentage calculations for items and shipping methods

packages/promotion/src/utils/compute-actions/buy-get.ts

@@ -46,7 +46,10 @@ export function getComputedActionsForBuyGet(
   const validItemsForTargetRules = itemsContext
     .filter((item) => areRulesValidForContext(targetRules, item))
     .sort((a, b) => {
-      return b.unit_price - a.unit_price
+      const aPrice = a.subtotal / a.quantity
+      const bPrice = b.subtotal / b.quantity
+
+      return bPrice - aPrice
     })
 
   let remainingQtyToApply = applyToQuantity
@@ -54,7 +57,7 @@ export function getComputedActionsForBuyGet(
   for (const method of validItemsForTargetRules) {
     const appliedPromoValue = methodIdPromoValueMap.get(method.id) || 0
     const multiplier = Math.min(method.quantity, remainingQtyToApply)
-    const amount = method.unit_price * multiplier
+    const amount = (method.subtotal / method.quantity) * multiplier
     const newRemainingQtyToApply = remainingQtyToApply - multiplier
 
     if (newRemainingQtyToApply < 0 || amount <= 0) {

packages/promotion/src/utils/compute-actions/items.ts

@@ -5,6 +5,7 @@ import {
 import {
   ApplicationMethodAllocation,
   ApplicationMethodTargetType,
+  ApplicationMethodType,
   ComputedActions,
   MedusaError,
 } from "@medusajs/utils"
@@ -67,10 +68,15 @@ export function applyPromotionToItems(
         method.quantity,
         applicationMethod?.max_quantity!
       )
-      const promotionValue =
-        parseFloat(applicationMethod!.value!) * quantityMultiplier
-      const applicableTotal =
-        method.unit_price * quantityMultiplier - appliedPromoValue
+      const totalItemValue =
+        (method.subtotal / method.quantity) * quantityMultiplier
+      let promotionValue = parseFloat(applicationMethod!.value!)
+      const applicableTotal = totalItemValue - appliedPromoValue
+
+      if (applicationMethod?.type === ApplicationMethodType.PERCENTAGE) {
+        promotionValue = (promotionValue / 100) * applicableTotal
+      }
+
       const amount = Math.min(promotionValue, applicableTotal)
 
       if (amount <= 0) {
@@ -106,18 +112,32 @@ export function applyPromotionToItems(
   ) {
     const totalApplicableValue = items!.reduce((acc, method) => {
       const appliedPromoValue = methodIdPromoValueMap.get(method.id) || 0
-      return acc + method.unit_price * method.quantity - appliedPromoValue
+      return (
+        acc +
+        (method.subtotal / method.quantity) * method.quantity -
+        appliedPromoValue
+      )
     }, 0)
 
     for (const method of items!) {
-      const promotionValue = parseFloat(applicationMethod!.value!)
       const appliedPromoValue = methodIdPromoValueMap.get(method.id) || 0
+      const promotionValue = parseFloat(applicationMethod!.value!)
       const applicableTotal =
-        method.unit_price * method.quantity - appliedPromoValue
+        (method.subtotal / method.quantity) * method.quantity -
+        appliedPromoValue
+
+      if (applicableTotal <= 0) {
+        continue
+      }
 
       // TODO: should we worry about precision here?
-      const applicablePromotionValue =
+      let applicablePromotionValue =
         (applicableTotal / totalApplicableValue) * promotionValue
+
+      if (applicationMethod?.type === ApplicationMethodType.PERCENTAGE) {
+        applicablePromotionValue = (promotionValue / 100) * applicableTotal
+      }
+
       const amount = Math.min(applicablePromotionValue, applicableTotal)
 
       if (amount <= 0) {
@@ -135,6 +155,8 @@ export function applyPromotionToItems(
         continue
       }
 
+      methodIdPromoValueMap.set(method.id, appliedPromoValue + amount)
+
       computedActions.push({
         action: ComputedActions.ADD_ITEM_ADJUSTMENT,
         item_id: method.id,

packages/promotion/src/utils/compute-actions/shipping-methods.ts

@@ -2,6 +2,7 @@ import { PromotionTypes } from "@medusajs/types"
 import {
   ApplicationMethodAllocation,
   ApplicationMethodTargetType,
+  ApplicationMethodType,
   ComputedActions,
   MedusaError,
 } from "@medusajs/utils"
@@ -55,8 +56,13 @@ export function applyPromotionToShippingMethods(
   if (allocation === ApplicationMethodAllocation.EACH) {
     for (const method of shippingMethods!) {
       const appliedPromoValue = methodIdPromoValueMap.get(method.id) || 0
-      const promotionValue = parseFloat(applicationMethod!.value!)
-      const applicableTotal = method.unit_price - appliedPromoValue
+      let promotionValue = parseFloat(applicationMethod!.value!)
+      const applicableTotal = method.subtotal - appliedPromoValue
+
+      if (applicationMethod?.type === ApplicationMethodType.PERCENTAGE) {
+        promotionValue = (promotionValue / 100) * applicableTotal
+      }
+
       const amount = Math.min(promotionValue, applicableTotal)
 
       if (amount <= 0) {
@@ -89,7 +95,7 @@ export function applyPromotionToShippingMethods(
     const totalApplicableValue = shippingMethods!.reduce((acc, method) => {
       const appliedPromoValue = methodIdPromoValueMap.get(method.id) || 0
 
-      return acc + method.unit_price - appliedPromoValue
+      return acc + method.subtotal - appliedPromoValue
     }, 0)
 
     if (totalApplicableValue <= 0) {
@@ -98,14 +104,19 @@ export function applyPromotionToShippingMethods(
 
     for (const method of shippingMethods!) {
       const promotionValue = parseFloat(applicationMethod!.value!)
-      const applicableTotal = method.unit_price
+      const applicableTotal = method.subtotal
       const appliedPromoValue = methodIdPromoValueMap.get(method.id) || 0
 
       // TODO: should we worry about precision here?
-      const applicablePromotionValue =
+      let applicablePromotionValue =
         (applicableTotal / totalApplicableValue) * promotionValue -
         appliedPromoValue
 
+      if (applicationMethod?.type === ApplicationMethodType.PERCENTAGE) {
+        applicablePromotionValue =
+          (promotionValue / 100) * (applicableTotal - appliedPromoValue)
+      }
+
       const amount = Math.min(applicablePromotionValue, applicableTotal)
 
       if (amount <= 0) {

packages/promotion/src/utils/validations/application-method.ts

@@ -37,11 +37,23 @@ export function validateApplicationMethodAttributes(
   const applyToQuantity =
     data.apply_to_quantity || applicationMethod?.apply_to_quantity
   const targetType = data.target_type || applicationMethod?.target_type
+  const type = data.type || applicationMethod?.type
   const applicationMethodType = data.type || applicationMethod?.type
+  const value = parseFloat(data.value! || applicationMethod?.value!)
   const maxQuantity = data.max_quantity || applicationMethod.max_quantity
   const allocation = data.allocation || applicationMethod.allocation
   const allTargetTypes: string[] = Object.values(ApplicationMethodTargetType)
 
+  if (
+    type === ApplicationMethodType.PERCENTAGE &&
+    (value <= 0 || value > 100)
+  ) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `Application Method value should be a percentage number between 0 and 100`
+    )
+  }
+
   if (promotion?.type === PromotionType.BUYGET) {
     if (!isPresent(applyToQuantity)) {
       throw new MedusaError(