chore(): Reorganize modules (#7210)

**What**
Move all modules to the modules directory

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

@@ -0,0 +1,137 @@
+import {
+  ApplicationMethodAllocation,
+  ApplicationMethodTargetType,
+  ApplicationMethodType,
+  isDefined,
+  isPresent,
+  MedusaError,
+  PromotionType,
+} from "@medusajs/utils"
+import { Promotion } from "@models"
+import { CreateApplicationMethodDTO, UpdateApplicationMethodDTO } from "@types"
+
+export const allowedAllocationTargetTypes: string[] = [
+  ApplicationMethodTargetType.SHIPPING_METHODS,
+  ApplicationMethodTargetType.ITEMS,
+]
+
+export const allowedAllocationTypes: string[] = [
+  ApplicationMethodAllocation.ACROSS,
+  ApplicationMethodAllocation.EACH,
+]
+
+export const allowedAllocationForQuantity: string[] = [
+  ApplicationMethodAllocation.EACH,
+]
+
+export function validateApplicationMethodAttributes(
+  data: UpdateApplicationMethodDTO | CreateApplicationMethodDTO,
+  promotion: Promotion
+) {
+  const applicationMethod = promotion?.application_method || {}
+  const buyRulesMinQuantity =
+    data.buy_rules_min_quantity || applicationMethod?.buy_rules_min_quantity
+  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 = 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 &&
+    (typeof value !== "number" || 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(
+        MedusaError.Types.INVALID_DATA,
+        `apply_to_quantity is a required field for Promotion type of ${PromotionType.BUYGET}`
+      )
+    }
+
+    if (!isPresent(buyRulesMinQuantity)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `buy_rules_min_quantity is a required field for Promotion type of ${PromotionType.BUYGET}`
+      )
+    }
+  }
+
+  if (
+    allocation === ApplicationMethodAllocation.ACROSS &&
+    isPresent(maxQuantity)
+  ) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `application_method.max_quantity is not allowed to be set for allocation (${ApplicationMethodAllocation.ACROSS})`
+    )
+  }
+
+  if (!allTargetTypes.includes(targetType)) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `application_method.target_type should be one of ${allTargetTypes.join(
+        ", "
+      )}`
+    )
+  }
+
+  const allTypes: string[] = Object.values(ApplicationMethodType)
+
+  if (!allTypes.includes(applicationMethodType)) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `application_method.type should be one of ${allTypes.join(", ")}`
+    )
+  }
+
+  if (
+    allowedAllocationTargetTypes.includes(targetType) &&
+    !allowedAllocationTypes.includes(allocation || "")
+  ) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `application_method.allocation should be either '${allowedAllocationTypes.join(
+        " OR "
+      )}' when application_method.target_type is either '${allowedAllocationTargetTypes.join(
+        " OR "
+      )}'`
+    )
+  }
+
+  const allAllocationTypes: string[] = Object.values(
+    ApplicationMethodAllocation
+  )
+
+  if (allocation && !allAllocationTypes.includes(allocation)) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `application_method.allocation should be one of ${allAllocationTypes.join(
+        ", "
+      )}`
+    )
+  }
+
+  if (
+    allocation &&
+    allowedAllocationForQuantity.includes(allocation) &&
+    !isDefined(maxQuantity)
+  ) {
+    throw new MedusaError(
+      MedusaError.Types.INVALID_DATA,
+      `application_method.max_quantity is required when application_method.allocation is '${allowedAllocationForQuantity.join(
+        " OR "
+      )}'`
+    )
+  }
+}

packages/modules/promotion/src/utils/validations/index.ts

@@ -0,0 +1,2 @@
+export * from "./application-method"
+export * from "./promotion-rule"

packages/modules/promotion/src/utils/validations/promotion-rule.ts

@@ -0,0 +1,104 @@
+import { PromotionRuleDTO, PromotionRuleOperatorValues } from "@medusajs/types"
+import {
+  isPresent,
+  isString,
+  MedusaError,
+  pickValueFromObject,
+  PromotionRuleOperator,
+} from "@medusajs/utils"
+import { CreatePromotionRuleDTO } from "@types"
+
+export function validatePromotionRuleAttributes(
+  promotionRulesData: CreatePromotionRuleDTO[]
+) {
+  const errors: string[] = []
+
+  for (const promotionRuleData of promotionRulesData) {
+    if (!isPresent(promotionRuleData.attribute)) {
+      errors.push("rules[].attribute is a required field")
+    }
+
+    if (!isPresent(promotionRuleData.operator)) {
+      errors.push("rules[].operator is a required field")
+    }
+
+    if (isPresent(promotionRuleData.operator)) {
+      const allowedOperators: PromotionRuleOperatorValues[] = Object.values(
+        PromotionRuleOperator
+      )
+
+      if (!allowedOperators.includes(promotionRuleData.operator)) {
+        errors.push(
+          `rules[].operator (${
+            promotionRuleData.operator
+          }) is invalid. It should be one of ${allowedOperators.join(", ")}`
+        )
+      }
+    } else {
+      errors.push("rules[].operator is a required field")
+    }
+  }
+
+  if (!errors.length) return
+
+  throw new MedusaError(MedusaError.Types.INVALID_DATA, errors.join(", "))
+}
+
+export function areRulesValidForContext(
+  rules: PromotionRuleDTO[],
+  context: Record<string, any>
+): boolean {
+  return rules.every((rule) => {
+    const validRuleValues = rule.values?.map((ruleValue) => ruleValue.value)
+
+    if (!rule.attribute) {
+      return false
+    }
+
+    const valuesToCheck = pickValueFromObject(rule.attribute, context)
+
+    return evaluateRuleValueCondition(
+      validRuleValues.filter(isString),
+      rule.operator!,
+      valuesToCheck
+    )
+  })
+}
+
+export function evaluateRuleValueCondition(
+  ruleValues: string[],
+  operator: string,
+  ruleValuesToCheck: string[] | string
+) {
+  if (!Array.isArray(ruleValuesToCheck)) {
+    ruleValuesToCheck = [ruleValuesToCheck]
+  }
+
+  return ruleValuesToCheck.every((ruleValueToCheck: string) => {
+    if (operator === "in" || operator === "eq") {
+      return ruleValues.some((ruleValue) => ruleValue === ruleValueToCheck)
+    }
+
+    if (operator === "ne") {
+      return ruleValues.some((ruleValue) => ruleValue !== ruleValueToCheck)
+    }
+
+    if (operator === "gt") {
+      return ruleValues.some((ruleValue) => ruleValue > ruleValueToCheck)
+    }
+
+    if (operator === "gte") {
+      return ruleValues.some((ruleValue) => ruleValue >= ruleValueToCheck)
+    }
+
+    if (operator === "lt") {
+      return ruleValues.some((ruleValue) => ruleValue < ruleValueToCheck)
+    }
+
+    if (operator === "lte") {
+      return ruleValues.some((ruleValue) => ruleValue <= ruleValueToCheck)
+    }
+
+    return false
+  })
+}