chore(): Reorganize modules (#7210)

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

packages/modules/order/src/utils/actions/cancel-return.ts

@@ -0,0 +1,73 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.CANCEL_RETURN, {
+  operation({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.return_requested_quantity ??= 0
+
+    existing.detail.return_requested_quantity = MathBN.sub(
+      existing.detail.return_requested_quantity,
+      action.details.quantity
+    )
+
+    return action.details.unit_price * action.details.quantity
+  },
+  revert({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.return_requested_quantity = MathBN.add(
+      existing.detail.return_requested_quantity,
+      action.details.quantity
+    )
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.details?.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Details reference ID is required."
+      )
+    }
+
+    if (!isDefined(action.amount) && !isDefined(action.details?.unit_price)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Unit price of item ${action.reference_id} is required if no action.amount is provided.`
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity to cancel return of item ${refId} is required.`
+      )
+    }
+
+    const greater = MathBN.gt(
+      action.details?.quantity,
+      existing.detail?.return_requested_quantity
+    )
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Cannot cancel more items than what was requested to return for item ${refId}.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/cancel.ts

@@ -0,0 +1,6 @@
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.CANCEL, {
+  void: true,
+})

packages/modules/order/src/utils/actions/fulfill-item.ts

@@ -0,0 +1,71 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.FULFILL_ITEM, {
+  operation({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.fulfilled_quantity ??= 0
+
+    existing.detail.fulfilled_quantity = MathBN.add(
+      existing.detail.fulfilled_quantity,
+      action.details.quantity
+    )
+  },
+  revert({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.reference_id
+    )!
+
+    existing.detail.fulfilled_quantity = MathBN.sub(
+      existing.detail.fulfilled_quantity,
+      action.details.quantity
+    )
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.details?.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Reference ID is required."
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity to fulfill of item ${refId} is required.`
+      )
+    }
+
+    if (action.details?.quantity < 1) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity of item ${refId} must be greater than 0.`
+      )
+    }
+
+    const notFulfilled = MathBN.sub(
+      existing.quantity,
+      existing.detail?.fulfilled_quantity
+    )
+    const greater = MathBN.gt(action.details?.quantity, notFulfilled)
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Cannot fulfill more items than what was ordered for item ${refId}.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/index.ts

@@ -0,0 +1,10 @@
+export * from "./cancel"
+export * from "./cancel-return"
+export * from "./fulfill-item"
+export * from "./item-add"
+export * from "./item-remove"
+export * from "./receive-damaged-return-item"
+export * from "./receive-return-item"
+export * from "./return-item"
+export * from "./ship-item"
+export * from "./shipping-add"

packages/modules/order/src/utils/actions/item-add.ts

@@ -0,0 +1,79 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { VirtualOrder } from "@types"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_ADD, {
+  operation({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.reference_id
+    )
+
+    if (existing) {
+      existing.detail.quantity ??= 0
+
+      existing.quantity = MathBN.add(existing.quantity, action.details.quantity)
+
+      existing.detail.quantity = MathBN.add(
+        existing.detail.quantity,
+        action.details.quantity
+      )
+    } else {
+      currentOrder.items.push({
+        id: action.reference_id!,
+        unit_price: action.details.unit_price,
+        quantity: action.details.quantity,
+      } as VirtualOrder["items"][0])
+    }
+
+    return MathBN.mult(action.details.unit_price, action.details.quantity)
+  },
+  revert({ action, currentOrder }) {
+    const existingIndex = currentOrder.items.findIndex(
+      (item) => item.id === action.reference_id
+    )
+
+    if (existingIndex > -1) {
+      const existing = currentOrder.items[existingIndex]
+      existing.quantity = MathBN.sub(existing.quantity, action.details.quantity)
+      existing.detail.quantity = MathBN.sub(
+        existing.detail.quantity,
+        action.details.quantity
+      )
+
+      if (MathBN.lte(existing.quantity, 0)) {
+        currentOrder.items.splice(existingIndex, 1)
+      }
+    }
+  },
+  validate({ action }) {
+    const refId = action.reference_id
+    if (!isDefined(action.reference_id)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Reference ID is required."
+      )
+    }
+
+    if (!isDefined(action.amount) && !isDefined(action.details?.unit_price)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Unit price of item ${refId} is required if no action.amount is provided.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity of item ${refId} is required.`
+      )
+    }
+
+    if (MathBN.lt(action.details?.quantity, 1)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity of item ${refId} must be greater than 0.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/item-remove.ts

@@ -0,0 +1,99 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { VirtualOrder } from "@types"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_REMOVE, {
+  isDeduction: true,
+  operation({ action, currentOrder }) {
+    const existingIndex = currentOrder.items.findIndex(
+      (item) => item.id === action.reference_id
+    )
+
+    const existing = currentOrder.items[existingIndex]
+
+    existing.detail.quantity ??= 0
+
+    existing.quantity = MathBN.sub(existing.quantity, action.details.quantity)
+    existing.detail.quantity = MathBN.sub(
+      existing.detail.quantity,
+      action.details.quantity
+    )
+
+    if (MathBN.lte(existing.quantity, 0)) {
+      currentOrder.items.splice(existingIndex, 1)
+    }
+
+    return MathBN.mult(existing.unit_price, action.details.quantity)
+  },
+  revert({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.reference_id
+    )
+
+    if (existing) {
+      existing.quantity = MathBN.add(existing.quantity, action.details.quantity)
+      existing.detail.quantity = MathBN.add(
+        existing.detail.quantity,
+        action.details.quantity
+      )
+    } else {
+      currentOrder.items.push({
+        id: action.reference_id!,
+        unit_price: action.details.unit_price,
+        quantity: action.details.quantity,
+      } as VirtualOrder["items"][0])
+    }
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Reference ID is required."
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!isDefined(action.amount) && !isDefined(action.details?.unit_price)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Unit price of item ${refId} is required if no action.amount is provided.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity of item ${refId} is required.`
+      )
+    }
+
+    if (MathBN.lt(action.details?.quantity, 1)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity of item ${refId} must be greater than 0.`
+      )
+    }
+
+    const notFulfilled = MathBN.sub(
+      existing.quantity,
+      existing.detail?.fulfilled_quantity
+    )
+
+    const greater = MathBN.gt(action.details?.quantity, notFulfilled)
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Cannot remove fulfilled item: Item ${refId}.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/receive-damaged-return-item.ts

@@ -0,0 +1,112 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { EVENT_STATUS } from "@types"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(
+  ChangeActionType.RECEIVE_DAMAGED_RETURN_ITEM,
+  {
+    isDeduction: true,
+    commitsAction: "return_item",
+    operation({ action, currentOrder, previousEvents }) {
+      const existing = currentOrder.items.find(
+        (item) => item.id === action.details.reference_id
+      )!
+
+      let toReturn = action.details.quantity
+
+      existing.detail.return_dismissed_quantity ??= 0
+      existing.detail.return_requested_quantity ??= 0
+
+      existing.detail.return_dismissed_quantity = MathBN.add(
+        existing.detail.return_dismissed_quantity,
+        toReturn
+      )
+      existing.detail.return_requested_quantity = MathBN.sub(
+        existing.detail.return_requested_quantity,
+        toReturn
+      )
+
+      if (previousEvents) {
+        for (const previousEvent of previousEvents) {
+          previousEvent.original_ = JSON.parse(JSON.stringify(previousEvent))
+
+          let ret = MathBN.min(toReturn, previousEvent.details.quantity)
+          toReturn = MathBN.sub(toReturn, ret)
+
+          previousEvent.details.quantity = MathBN.sub(
+            previousEvent.details.quantity,
+            ret
+          )
+          if (MathBN.lte(previousEvent.details.quantity, 0)) {
+            previousEvent.status = EVENT_STATUS.DONE
+          }
+        }
+      }
+
+      return MathBN.mult(existing.unit_price, action.details.quantity)
+    },
+    revert({ action, currentOrder, previousEvents }) {
+      const existing = currentOrder.items.find(
+        (item) => item.id === action.details.reference_id
+      )!
+
+      existing.detail.return_dismissed_quantity = MathBN.sub(
+        existing.detail.return_dismissed_quantity,
+        action.details.quantity
+      )
+      existing.detail.return_requested_quantity = MathBN.add(
+        existing.detail.return_requested_quantity,
+        action.details.quantity
+      )
+
+      if (previousEvents) {
+        for (const previousEvent of previousEvents) {
+          if (!previousEvent.original_) {
+            continue
+          }
+
+          previousEvent.details = JSON.parse(
+            JSON.stringify(previousEvent.original_.details)
+          )
+          delete previousEvent.original_
+
+          previousEvent.status = EVENT_STATUS.PENDING
+        }
+      }
+    },
+    validate({ action, currentOrder }) {
+      const refId = action.details?.reference_id
+      if (!isDefined(refId)) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          "Details reference ID is required."
+        )
+      }
+
+      const existing = currentOrder.items.find((item) => item.id === refId)
+
+      if (!existing) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Reference ID "${refId}" not found.`
+        )
+      }
+
+      if (!action.details?.quantity) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Quantity to return of item ${refId} is required.`
+        )
+      }
+
+      const quantityRequested = existing?.detail.return_requested_quantity || 0
+      if (action.details?.quantity > quantityRequested) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Cannot receive more items than what was requested to be returned for item ${refId}.`
+        )
+      }
+    },
+  }
+)

packages/modules/order/src/utils/actions/receive-return-item.ts

@@ -0,0 +1,119 @@
+import {
+  MathBN,
+  MedusaError,
+  isDefined,
+  transformPropertiesToBigNumber,
+} from "@medusajs/utils"
+import { EVENT_STATUS } from "@types"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.RECEIVE_RETURN_ITEM, {
+  isDeduction: true,
+  commitsAction: "return_item",
+  operation({ action, currentOrder, previousEvents }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    let toReturn = action.details.quantity
+
+    existing.detail.return_received_quantity ??= 0
+    existing.detail.return_requested_quantity ??= 0
+
+    existing.detail.return_received_quantity = MathBN.add(
+      existing.detail.return_received_quantity,
+      toReturn
+    )
+    existing.detail.return_requested_quantity = MathBN.sub(
+      existing.detail.return_requested_quantity,
+      toReturn
+    )
+
+    if (previousEvents) {
+      for (const previousEvent of previousEvents) {
+        previousEvent.original_ = JSON.parse(JSON.stringify(previousEvent))
+
+        let ret = MathBN.min(toReturn, previousEvent.details.quantity)
+        toReturn = MathBN.sub(toReturn, ret)
+
+        previousEvent.details.quantity = MathBN.sub(
+          previousEvent.details.quantity,
+          ret
+        )
+
+        if (MathBN.lte(previousEvent.details.quantity, 0)) {
+          previousEvent.status = EVENT_STATUS.DONE
+        }
+      }
+    }
+
+    return MathBN.mult(existing.unit_price, action.details.quantity)
+  },
+  revert({ action, currentOrder, previousEvents }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.return_received_quantity = MathBN.sub(
+      existing.detail.return_received_quantity,
+      action.details.quantity
+    )
+    existing.detail.return_requested_quantity = MathBN.add(
+      existing.detail.return_requested_quantity,
+      action.details.quantity
+    )
+
+    if (previousEvents) {
+      for (const previousEvent of previousEvents) {
+        if (!previousEvent.original_) {
+          continue
+        }
+
+        previousEvent.details = JSON.parse(
+          JSON.stringify(previousEvent.original_.details)
+        )
+        transformPropertiesToBigNumber(previousEvent.details?.metadata)
+
+        delete previousEvent.original_
+
+        previousEvent.status = EVENT_STATUS.PENDING
+      }
+    }
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.details?.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Details reference ID is required."
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity to receive return of item ${refId} is required.`
+      )
+    }
+
+    const quantityRequested = existing?.detail?.return_requested_quantity || 0
+
+    const greater = MathBN.gt(action.details?.quantity, quantityRequested)
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Cannot receive more items than what was requested to be returned for item ${refId}.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/return-item.ts

@@ -0,0 +1,69 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.RETURN_ITEM, {
+  isDeduction: true,
+  awaitRequired: true,
+  operation({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.return_requested_quantity ??= 0
+    existing.detail.return_requested_quantity = MathBN.add(
+      existing.detail.return_requested_quantity,
+      action.details.quantity
+    )
+
+    return MathBN.mult(existing.unit_price, action.details.quantity)
+  },
+  revert({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.return_requested_quantity = MathBN.sub(
+      existing.detail.return_requested_quantity,
+      action.details.quantity
+    )
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.details?.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Details reference ID is required."
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity to return of item ${refId} is required.`
+      )
+    }
+
+    const quantityAvailable = MathBN.sub(
+      existing!.detail?.shipped_quantity ?? 0,
+      existing!.detail?.return_requested_quantity ?? 0
+    )
+
+    const greater = MathBN.gt(action.details?.quantity, quantityAvailable)
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Cannot request to return more items than what was shipped for item ${refId}.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/ship-item.ts

@@ -0,0 +1,72 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.SHIP_ITEM, {
+  operation({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.shipped_quantity ??= 0
+
+    existing.detail.shipped_quantity = MathBN.add(
+      existing.detail.shipped_quantity,
+      action.details.quantity
+    )
+  },
+  revert({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.reference_id
+    )!
+
+    existing.detail.shipped_quantity = MathBN.sub(
+      existing.detail.shipped_quantity,
+      action.details.quantity
+    )
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.details?.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Reference ID is required."
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity to ship of item ${refId} is required.`
+      )
+    }
+
+    if (MathBN.lt(action.details?.quantity, 1)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity of item ${refId} must be greater than 0.`
+      )
+    }
+
+    const notShipped = MathBN.sub(
+      existing.detail?.fulfilled_quantity,
+      existing.detail?.shipped_quantity
+    )
+
+    const greater = MathBN.gt(action.details?.quantity, notShipped)
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Cannot ship more items than what was fulfilled for item ${refId}.`
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/shipping-add.ts

@@ -0,0 +1,46 @@
+import { MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.SHIPPING_ADD, {
+  operation({ action, currentOrder }) {
+    const shipping = Array.isArray(currentOrder.shipping_methods)
+      ? currentOrder.shipping_methods
+      : [currentOrder.shipping_methods]
+
+    shipping.push({
+      id: action.reference_id!,
+      price: action.amount as number,
+    })
+
+    currentOrder.shipping_methods = shipping
+  },
+  revert({ action, currentOrder }) {
+    const shipping = Array.isArray(currentOrder.shipping_methods)
+      ? currentOrder.shipping_methods
+      : [currentOrder.shipping_methods]
+
+    const existingIndex = shipping.findIndex(
+      (item) => item.id === action.reference_id
+    )
+
+    if (existingIndex > -1) {
+      shipping.splice(existingIndex, 1)
+    }
+  },
+  validate({ action }) {
+    if (!action.reference_id) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Reference ID is required."
+      )
+    }
+
+    if (!isDefined(action.amount)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Amount is required."
+      )
+    }
+  },
+})

packages/modules/order/src/utils/actions/write-off-item.ts

@@ -0,0 +1,61 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(ChangeActionType.WRITE_OFF_ITEM, {
+  operation({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.written_off_quantity ??= 0
+    existing.detail.written_off_quantity = MathBN.add(
+      existing.detail.written_off_quantity,
+      action.details.quantity
+    )
+  },
+  revert({ action, currentOrder }) {
+    const existing = currentOrder.items.find(
+      (item) => item.id === action.details.reference_id
+    )!
+
+    existing.detail.written_off_quantity = MathBN.sub(
+      existing.detail.written_off_quantity,
+      action.details.quantity
+    )
+  },
+  validate({ action, currentOrder }) {
+    const refId = action.details?.reference_id
+    if (!isDefined(refId)) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Details reference ID is required."
+      )
+    }
+
+    const existing = currentOrder.items.find((item) => item.id === refId)
+
+    if (!existing) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Reference ID "${refId}" not found.`
+      )
+    }
+
+    if (!action.details?.quantity) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        `Quantity to write-off item ${refId} is required.`
+      )
+    }
+
+    const quantityAvailable = existing!.quantity ?? 0
+    const greater = MathBN.gt(action.details?.quantity, quantityAvailable)
+    if (greater) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_DATA,
+        "Cannot claim more items than what was ordered."
+      )
+    }
+  },
+})