fix: Compute "virtual" adjustments for order previews (#13306)

* wip * add wip * wip * reuse action * finish first draft * fix tests * cleanup * Only compute adjustments when necessary * Create hot-carrots-look.md * address comments * minor tweaks * fix pay col * fix test * wip * Dwip * wip * fix: adjustment typo * fix: import * fix: workflow imports * wip: update test * feat: upsert versioned adjustments when previewing order * fix: revert unique codes change * fix: order spec test with versioning * wip: save * feat: make adjustments work for preview and confirm flow, wip base repo filtering of older version adjustments * fix: missing populate where * wip: populate where loading versioned adjustments * fix: filter out older adjustment versions * temp: comment adjustments in repo * test: add adjustment if no version * wip: configure populate where in order base repository * fix: rm manual filtering * fix: revert base repo changes * fix: revert * fix: use order item version instead of order version * fix: rm only in test * fix: update case spec * fix: remove sceanrio, wip test with draft promotion * feat: test correct adjustments when disabling promotion * feat: complex test case * feat: test consecutive order edits * feat: 2 promotions test case with a fixed promo * feat: migrate existing order line item adjustments to order items latest version * feat: update dep after merge * wip: load adjustments separatley * feat: adjustments collections * fix: spread result, handle related entity case * fix: update lock * feat: make sure version is loaded, refactor, handle related entity case * fix: check fields * feat: loading adjustments for list and count * fix: correct items version field * fix: rm empty array * fix: wip order modules spec * fix: order module specs * feat: preinit items adjustments * fix: rm only * fix: rm only * chore: cleanup * fix: migration files * fix: dont change formatting * fix: core package build * chore: more cleanup * fix: item update util * fix: duplicate import * fix: refresh adjustments for exchanges (#13992) * wip: exchange adjustments * feat: test - receive items * feat: finish test case * fix: casing * fix(draft-orders, core-flows, orders) refresh adjustments for draft orders (#14025) * wip: draft orders adjustments refresh * feat: rewrite to use REPLACE action + test * fix: rm only * feat: cleanup old REPLACE actions * feat: cleanup adjustemnts when 0 promotions * wip: canceling draft order * fix: make version arg optional * fix: restore promotion links * feat: test reverting on cancelation * fix: address comments in tests * wip: fix summary on preview * fix: get pending diff on preview summary from total * fix: revert pending diff change --------- Co-authored-by: fPolic <mainacc.polic@gmail.com> Co-authored-by: Frane Polić <16856471+fPolic@users.noreply.github.com>
2025-11-25 10:41:14 +01:00
parent 0ddd9e36b5
commit 78842af1c3
60 changed files with 3271 additions and 233 deletions
@@ -1,56 +1,63 @@
-import type {
-  CartDTO,
-  IPromotionModuleService,
+import {
+  ComputeActionContext,
+  ComputeActionOptions,
+  IPromotionModuleService
 } from "@medusajs/framework/types"
 import { Modules } from "@medusajs/framework/utils"
 import { StepResponse, createStep } from "@medusajs/framework/workflows-sdk"

 /**
- * The details of the cart and its applied promotions.
+ * The details of the items and shipping methods and its applied promotions.
 */
 export interface GetActionsToComputeFromPromotionsStepInput {
  /**
-   * The cart to compute the actions for.
+   * The items and shipping methods to compute the actions for.
   */
-  cart: CartDTO
+  computeActionContext: ComputeActionContext
  /**
-   * The promotion codes applied on the cart.
+   * The promotion codes applied on the items and shipping methods.
   */
  promotionCodesToApply: string[]
+  /**
+   * The options to configure how the actions are computed.
+   */
+  options?: ComputeActionOptions
 }

 export const getActionsToComputeFromPromotionsStepId =
  "get-actions-to-compute-from-promotions"
 /**
 * This step retrieves the actions to compute based on the promotions
- * applied on a cart.
+ * applied on items and shipping methods.
 *
 * :::tip
 *
- * You can use the {@link retrieveCartStep} to retrieve a cart's details.
+ * You can use the {@link retrieveCartStep} to retrieve items and shipping methods' details.
 *
 * :::
 *
 * @example
 * const data = getActionsToComputeFromPromotionsStep({
- *   // retrieve the details of the cart from another workflow
+ *   // retrieve the details of the items and shipping methods from another workflow
 *   // or in another step using the Cart Module's service
- *   cart,
+ *   computeActionContext,
 *   promotionCodesToApply: ["10OFF"]
 * })
 */
 export const getActionsToComputeFromPromotionsStep = createStep(
  getActionsToComputeFromPromotionsStepId,
  async (data: GetActionsToComputeFromPromotionsStepInput, { container }) => {
-    const { cart, promotionCodesToApply = [] } = data
+    const { computeActionContext, promotionCodesToApply = [], options } = data

+    
    const promotionService = container.resolve<IPromotionModuleService>(
      Modules.PROMOTION
    )
-
+    
    const actionsToCompute = await promotionService.computeActions(
      promotionCodesToApply,
-      cart as any
+      computeActionContext,
+      options
    )

    return new StepResponse(actionsToCompute)
@@ -125,7 +125,7 @@ export const updateCartPromotionsWorkflow = createWorkflow(
    })

    const actions = getActionsToComputeFromPromotionsStep({
-      cart,
+      computeActionContext: cart,
      promotionCodesToApply,
    })

@@ -20,6 +20,10 @@ export interface CreateDraftOrderLineItemAdjustmentsStepInput {
   * The line item adjustments to create.
   */
  lineItemAdjustmentsToCreate: CreateLineItemAdjustmentDTO[]
+  /**
+   * The version of the order change to create the line item adjustments for.
+   */
+  version?: number
 }

 /**
@@ -43,7 +47,7 @@ export const createDraftOrderLineItemAdjustmentsStep = createStep(
    data: CreateDraftOrderLineItemAdjustmentsStepInput,
    { container }
  ) {
-    const { lineItemAdjustmentsToCreate = [], order_id } = data
+    const { lineItemAdjustmentsToCreate = [], order_id, version } = data

    if (!lineItemAdjustmentsToCreate?.length) {
      return new StepResponse(void 0, [])
@@ -65,6 +69,7 @@ export const createDraftOrderLineItemAdjustmentsStep = createStep(
    const lineItemAdjustments = await service.createOrderLineItemAdjustments(
      filteredAdjustments.map((adjustment) => ({
        ...adjustment,
+        version,
        order_id,
      }))
    )
@@ -1,8 +1,4 @@
-import {
-  ChangeActionType,
-  OrderChangeStatus,
-  PromotionActions,
-} from "@medusajs/framework/utils"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  transform,
@@ -24,8 +20,8 @@ import {
 } from "../../order"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const addDraftOrderItemsWorkflowId = "add-draft-order-items"

@@ -74,7 +70,7 @@ export const addDraftOrderItemsWorkflow = createWorkflow(

    const orderChange: OrderChangeDTO = useRemoteQueryStep({
      entry_point: "order_change",
-      fields: ["id", "status"],
+      fields: ["id", "status", "version"],
      variables: {
        filters: {
          order_id: input.order_id,
@@ -114,11 +110,9 @@ export const addDraftOrderItemsWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -21,8 +21,9 @@ import {
 } from "../../order"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { validatePromoCodesToAddStep } from "../steps/validate-promo-codes-to-add"
+import { updateDraftOrderPromotionsStep } from "../steps/update-draft-order-promotions"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"

 export const addDraftOrderPromotionWorkflowId = "add-draft-order-promotion"
@@ -82,7 +83,7 @@ export const addDraftOrderPromotionWorkflow = createWorkflow(

    const orderChange: OrderChangeDTO = useRemoteQueryStep({
      entry_point: "order_change",
-      fields: ["id", "status"],
+      fields: ["id", "status", "version"],
      variables: {
        filters: {
          order_id: input.order_id,
@@ -110,11 +111,15 @@ export const addDraftOrderPromotionWorkflow = createWorkflow(
      promotions,
    })

-    refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+    updateDraftOrderPromotionsStep({
+      id: input.order_id,
+      promo_codes: input.promo_codes,
+      action: PromotionActions.ADD,
+    })
+
+    computeDraftOrderAdjustmentsWorkflow.runAsStep({
      input: {
-        order,
-        promo_codes: input.promo_codes,
-        action: PromotionActions.ADD,
+        order_id: input.order_id,
      },
    })

@@ -3,7 +3,6 @@ import {
  isDefined,
  MedusaError,
  OrderChangeStatus,
-  PromotionActions,
  ShippingOptionPriceType,
 } from "@medusajs/framework/utils"
 import {
@@ -30,8 +29,8 @@ import { createOrderShippingMethods } from "../../order/steps/create-order-shipp
 import { prepareShippingMethod } from "../../order/utils/prepare-shipping-method"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 const validateShippingOptionStep = createStep(
  "validate-shipping-option",
@@ -187,19 +186,9 @@ export const addDraftOrderShippingMethodsWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      const refetchedOrder = useRemoteQueryStep({
-        entry_point: "orders",
-        fields: draftOrderFieldsForRefreshSteps,
-        variables: { id: input.order_id },
-        list: false,
-        throw_if_key_not_found: true,
-      }).config({ name: "refetched-order-query" })
-
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order: refetchedOrder,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -16,8 +16,8 @@ import { deleteOrderChangesStep, deleteOrderShippingMethods } from "../../order"
 import { restoreDraftOrderShippingMethodsStep } from "../steps/restore-draft-order-shipping-methods"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { updateDraftOrderPromotionsStep } from "../steps/update-draft-order-promotions"

 export const cancelDraftOrderEditWorkflowId = "cancel-draft-order-edit"

@@ -85,34 +85,6 @@ export const cancelDraftOrderEditWorkflow = createWorkflow(

    validateDraftOrderChangeStep({ order, orderChange })

-    const shippingToRemove = transform(
-      { orderChange, input },
-      ({ orderChange }) => {
-        return (orderChange.actions ?? [])
-          .filter((a) => a.action === ChangeActionType.SHIPPING_ADD)
-          .map(({ reference_id }) => reference_id)
-      }
-    )
-
-    const shippingToRestore = transform(
-      { orderChange, input },
-      ({ orderChange }) => {
-        return (orderChange.actions ?? [])
-          .filter((a) => a.action === ChangeActionType.SHIPPING_UPDATE)
-          .map(({ reference_id, details }) => ({
-            id: reference_id,
-            before: {
-              shipping_option_id: details?.old_shipping_option_id,
-              amount: details?.old_amount,
-            },
-            after: {
-              shipping_option_id: details?.new_shipping_option_id,
-              amount: details?.new_amount,
-            },
-          }))
-      }
-    )
-
    const promotionsToRemove = transform(
      { orderChange, input },
      ({ orderChange }) => {
@@ -155,19 +127,45 @@ export const cancelDraftOrderEditWorkflow = createWorkflow(
      }
    )

+    updateDraftOrderPromotionsStep({
+      id: input.order_id,
+      promo_codes: promotionsToRefresh as string[],
+      action: PromotionActions.REPLACE,
+    })
+
+    const shippingToRemove = transform(
+      { orderChange, input },
+      ({ orderChange }) => {
+        return (orderChange.actions ?? [])
+          .filter((a) => a.action === ChangeActionType.SHIPPING_ADD)
+          .map(({ reference_id }) => reference_id)
+      }
+    )
+
+    const shippingToRestore = transform(
+      { orderChange, input },
+      ({ orderChange }) => {
+        return (orderChange.actions ?? [])
+          .filter((a) => a.action === ChangeActionType.SHIPPING_UPDATE)
+          .map(({ reference_id, details }) => ({
+            id: reference_id,
+            before: {
+              shipping_option_id: details?.old_shipping_option_id,
+              amount: details?.old_amount,
+            },
+            after: {
+              shipping_option_id: details?.new_shipping_option_id,
+              amount: details?.new_amount,
+            },
+          }))
+      }
+    )
+
    parallelize(
      deleteOrderChangesStep({ ids: [orderChange.id] }),
      deleteOrderShippingMethods({ ids: shippingToRemove })
    )

-    refreshDraftOrderAdjustmentsWorkflow.runAsStep({
-      input: {
-        order,
-        promo_codes: promotionsToRefresh,
-        action: PromotionActions.REPLACE,
-      },
-    })
-
    when(shippingToRestore, (methods) => !!methods?.length).then(() => {
      restoreDraftOrderShippingMethodsStep({
        shippingMethods: shippingToRestore as any,
@@ -0,0 +1,213 @@
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
+import {
+  createWorkflow,
+  transform,
+  when,
+  WorkflowData,
+  WorkflowResponse,
+} from "@medusajs/framework/workflows-sdk"
+import type {
+  ComputeActionContext,
+  OrderChangeDTO,
+  OrderDTO,
+  PromotionDTO,
+} from "@medusajs/framework/types"
+import {
+  getActionsToComputeFromPromotionsStep,
+  prepareAdjustmentsFromPromotionActionsStep,
+} from "../../cart"
+import { createOrderChangeActionsWorkflow } from "../../order/workflows/create-order-change-actions"
+import { previewOrderChangeStep } from "../../order/steps/preview-order-change"
+import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
+import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
+import { useRemoteQueryStep } from "../../common"
+import { acquireLockStep, releaseLockStep } from "../../locking"
+import { deleteOrderChangeActionsStep } from "../../order/steps/delete-order-change-actions"
+
+export const computeDraftOrderAdjustmentsWorkflowId =
+  "compute-draft-order-adjustments"
+
+/**
+ * The details of the draft order to refresh the adjustments for.
+ */
+export interface ComputeDraftOrderAdjustmentsWorkflowInput {
+  /**
+   * The ID of the draft order to refresh the adjustments for.
+   */
+  order_id: string
+}
+
+/**
+ * This workflow computes the adjustments or promotions for a draft order. It's used by other workflows
+ * to compute new adjustments for the promotions whenever changes are made to the draft order.
+ * Created adjustments are "virtual" meaning they live on the action and no line item adjustments records are created
+ * in the database until the edit is confirmed.
+ *
+ * You can use this workflow within your customizations or your own custom workflows, allowing you to wrap custom logic around
+ * computing the adjustments for a draft order.
+ *
+ * @example
+ * const { result } = await computeDraftOrderAdjustmentsWorkflow(container)
+ * .run({
+ *   input: {
+ *     order_id: "order_123",
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Refresh the promotions in a draft order.
+ */
+export const computeDraftOrderAdjustmentsWorkflow = createWorkflow(
+  computeDraftOrderAdjustmentsWorkflowId,
+  function (input: WorkflowData<ComputeDraftOrderAdjustmentsWorkflowInput>) {
+    acquireLockStep({
+      key: input.order_id,
+      timeout: 2,
+      ttl: 10,
+    })
+
+    const order: OrderDTO & { promotions: PromotionDTO[] } = useRemoteQueryStep(
+      {
+        entry_point: "orders",
+        fields: draftOrderFieldsForRefreshSteps,
+        variables: { id: input.order_id },
+        list: false,
+        throw_if_key_not_found: true,
+      }
+    ).config({ name: "order-query" })
+
+    const orderChange: OrderChangeDTO = useRemoteQueryStep({
+      entry_point: "order_change",
+      fields: ["id", "status", "version", "actions.*"],
+      variables: {
+        filters: {
+          order_id: input.order_id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validateDraftOrderChangeStep({ order, orderChange })
+
+    const toDeleteActions = transform(orderChange, (orderChange) => {
+      return orderChange.actions
+        .filter(
+          (action) =>
+            action.action === ChangeActionType.ITEM_ADJUSTMENTS_REPLACE
+        )
+        .map((action) => {
+          return action.id
+        })
+    })
+
+    when(toDeleteActions, (toDeleteActions) => toDeleteActions.length > 0).then(
+      () => {
+        // clean up old replace actions from the current order change
+        deleteOrderChangeActionsStep({ ids: toDeleteActions })
+      }
+    )
+
+    const previewedOrder = previewOrderChangeStep(input.order_id)
+
+    when(
+      { order },
+      ({ order }) => Array.isArray(order.promotions) && !order.promotions.length
+    ).then(() => {
+      const orderChangeActionAdjustmentsInput = transform(
+        { order, previewedOrder, orderChange },
+        ({ order, previewedOrder, orderChange }) => {
+          return previewedOrder.items.map((item) => {
+            return {
+              order_id: order.id,
+              order_change_id: orderChange.id,
+              version: orderChange.version,
+              action: ChangeActionType.ITEM_ADJUSTMENTS_REPLACE,
+              details: {
+                reference_id: item.id,
+                adjustments: [],
+              },
+            }
+          })
+        }
+      )
+
+      createOrderChangeActionsWorkflow
+        .runAsStep({ input: orderChangeActionAdjustmentsInput })
+        .config({ name: "order-change-action-adjustments-input-remove" })
+    })
+
+    when({ order }, ({ order }) => !!order.promotions?.length).then(() => {
+      const orderPromotions = transform({ order }, ({ order }) => {
+        return order.promotions
+          .map((p) => p.code)
+          .filter((p) => p !== undefined)
+      })
+
+      const actionsToComputeItemsInput = transform(
+        { previewedOrder, order },
+        ({ previewedOrder, order }) => {
+          return {
+            currency_code: order.currency_code,
+            items: previewedOrder.items.map((item) => ({
+              ...item,
+              // Buy-Get promotions rely on the product ID, so we need to manually set it before refreshing adjustments
+              product: { id: item.product_id },
+            })),
+          } as ComputeActionContext
+        }
+      )
+
+      const actions = getActionsToComputeFromPromotionsStep({
+        computeActionContext: actionsToComputeItemsInput,
+        promotionCodesToApply: orderPromotions,
+      })
+
+      const { lineItemAdjustmentsToCreate } =
+        prepareAdjustmentsFromPromotionActionsStep({ actions })
+
+      const orderChangeActionAdjustmentsInput = transform(
+        {
+          order,
+          previewedOrder,
+          orderChange,
+          lineItemAdjustmentsToCreate,
+        },
+        ({
+          order,
+          previewedOrder,
+          orderChange,
+          lineItemAdjustmentsToCreate,
+        }) => {
+          return previewedOrder.items.map((item) => {
+            const itemAdjustments = lineItemAdjustmentsToCreate.filter(
+              (adjustment) => adjustment.item_id === item.id
+            )
+
+            return {
+              order_change_id: orderChange.id,
+              order_id: order.id,
+              version: orderChange.version,
+              action: ChangeActionType.ITEM_ADJUSTMENTS_REPLACE,
+              details: {
+                reference_id: item.id,
+                adjustments: itemAdjustments,
+              },
+            }
+          })
+        }
+      )
+
+      createOrderChangeActionsWorkflow
+        .runAsStep({ input: orderChangeActionAdjustmentsInput })
+        .config({ name: "order-change-action-adjustments-input" })
+    })
+
+    releaseLockStep({
+      key: input.order_id,
+    })
+
+    return new WorkflowResponse(void 0)
+  }
+)
@@ -5,6 +5,7 @@ export * from "./begin-draft-order-edit"
 export * from "./cancel-draft-order-edit"
 export * from "./confirm-draft-order-edit"
 export * from "./convert-draft-order"
+export * from "./compute-draft-order-adjustments"
 export * from "./remove-draft-order-action-item"
 export * from "./remove-draft-order-action-shipping-method"
 export * from "./remove-draft-order-promotions"
@@ -51,6 +51,10 @@ export interface RefreshDraftOrderAdjustmentsWorkflowInput {
   * - Replace the existing promo codes with the new ones.
   */
  action: PromotionActions
+  /**
+   * The version of the order change to refresh the adjustments for.
+   */
+  version?: number
 }

 /**
@@ -92,7 +96,7 @@ export const refreshDraftOrderAdjustmentsWorkflow = createWorkflow(
    })

    const actions = getActionsToComputeFromPromotionsStep({
-      cart: input.order as any,
+      computeActionContext: input.order as any,
      promotionCodesToApply,
    })

@@ -114,6 +118,7 @@ export const refreshDraftOrderAdjustmentsWorkflow = createWorkflow(
      createDraftOrderLineItemAdjustmentsStep({
        lineItemAdjustmentsToCreate: lineItemAdjustmentsToCreate,
        order_id: input.order.id,
+        version: input.version,
      }),
      createDraftOrderShippingMethodAdjustmentsStep({
        shippingMethodAdjustmentsToCreate: shippingMethodAdjustmentsToCreate,
@@ -1,4 +1,4 @@
-import { OrderChangeStatus, PromotionActions } from "@medusajs/framework/utils"
+import { OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  transform,
@@ -20,8 +20,8 @@ import {
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { validateDraftOrderRemoveActionItemStep } from "../steps/validate-draft-order-remove-action-item"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const removeDraftOrderActionItemWorkflowId =
  "remove-draft-order-action-item"
@@ -109,11 +109,9 @@ export const removeDraftOrderActionItemWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order: refetchedOrder,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -1,4 +1,4 @@
-import { OrderChangeStatus, PromotionActions } from "@medusajs/framework/utils"
+import { OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  parallelize,
@@ -24,8 +24,8 @@ import { getDraftOrderPromotionContextStep } from "../steps/get-draft-order-prom
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { validateDraftOrderShippingMethodActionStep } from "../steps/validate-draft-order-shipping-method-action"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const removeDraftOrderActionShippingMethodWorkflowId =
  "remove-draft-order-action-shipping-method"
@@ -117,11 +117,9 @@ export const removeDraftOrderActionShippingMethodWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -21,9 +21,10 @@ import {
 } from "../../order"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { validatePromoCodesToRemoveStep } from "../steps/validate-promo-codes-to-remove"
+import { updateDraftOrderPromotionsStep } from "../steps/update-draft-order-promotions"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const removeDraftOrderPromotionsWorkflowId =
  "remove-draft-order-promotions"
@@ -83,7 +84,7 @@ export const removeDraftOrderPromotionsWorkflow = createWorkflow(

    const orderChange: OrderChangeDTO = useRemoteQueryStep({
      entry_point: "order_change",
-      fields: ["id", "status"],
+      fields: ["id", "status", "version"],
      variables: {
        filters: {
          order_id: input.order_id,
@@ -111,11 +112,15 @@ export const removeDraftOrderPromotionsWorkflow = createWorkflow(
      promotions,
    })

-    refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+    updateDraftOrderPromotionsStep({
+      id: input.order_id,
+      promo_codes: input.promo_codes,
+      action: PromotionActions.REMOVE,
+    })
+
+    computeDraftOrderAdjustmentsWorkflow.runAsStep({
      input: {
-        order,
-        promo_codes: input.promo_codes,
-        action: PromotionActions.REMOVE,
+        order_id: input.order_id,
      },
    })

@@ -1,8 +1,4 @@
-import {
-  ChangeActionType,
-  OrderChangeStatus,
-  PromotionActions,
-} from "@medusajs/framework/utils"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  transform,
@@ -18,8 +14,8 @@ import {
 } from "../../order"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const removeDraftOrderShippingMethodWorkflowId =
  "remove-draft-order-shipping-method"
@@ -103,19 +99,9 @@ export const removeDraftOrderShippingMethodWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      const refetchedOrder = useRemoteQueryStep({
-        entry_point: "orders",
-        fields: draftOrderFieldsForRefreshSteps,
-        variables: { id: input.order_id },
-        list: false,
-        throw_if_key_not_found: true,
-      }).config({ name: "refetched-order-query" })
-
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order: refetchedOrder,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -1,4 +1,4 @@
-import { OrderChangeStatus, PromotionActions } from "@medusajs/framework/utils"
+import { OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  transform,
@@ -21,8 +21,8 @@ import { getDraftOrderPromotionContextStep } from "../steps/get-draft-order-prom
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { validateDraftOrderUpdateActionItemStep } from "../steps/validate-draft-order-update-action-item"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const updateDraftOrderActionItemId = "update-draft-order-action-item"

@@ -134,11 +134,9 @@ export const updateDraftOrderActionItemWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order: context,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -1,4 +1,4 @@
-import { OrderChangeStatus, PromotionActions } from "@medusajs/framework/utils"
+import { OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  parallelize,
@@ -25,8 +25,8 @@ import { getDraftOrderPromotionContextStep } from "../steps/get-draft-order-prom
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { validateDraftOrderShippingMethodActionStep } from "../steps/validate-draft-order-shipping-method-action"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const updateDraftOrderActionShippingMethodWorkflowId =
  "update-draft-order-action-shipping-method"
@@ -159,11 +159,9 @@ export const updateDraftOrderActionShippingMethodWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -3,7 +3,6 @@ import {
  ChangeActionType,
  MathBN,
  OrderChangeStatus,
-  PromotionActions,
 } from "@medusajs/framework/utils"
 import {
  createWorkflow,
@@ -26,8 +25,8 @@ import {
 import { getDraftOrderPromotionContextStep } from "../steps/get-draft-order-promotion-context"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const updateDraftOrderItemWorkflowId = "update-draft-order-item"

@@ -72,7 +71,7 @@ export const updateDraftOrderItemWorkflow = createWorkflow(

    const orderChange: OrderChangeDTO = useRemoteQueryStep({
      entry_point: "order_change",
-      fields: ["id", "status"],
+      fields: ["id", "status", "version"],
      variables: {
        filters: {
          order_id: input.order_id,
@@ -133,11 +132,9 @@ export const updateDraftOrderItemWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order: context,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -1,8 +1,4 @@
-import {
-  ChangeActionType,
-  OrderChangeStatus,
-  PromotionActions,
-} from "@medusajs/framework/utils"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  createWorkflow,
  transform,
@@ -24,8 +20,8 @@ import {
 import { updateDraftOrderShippingMethodStep } from "../steps/update-draft-order-shipping-metod"
 import { validateDraftOrderChangeStep } from "../steps/validate-draft-order-change"
 import { draftOrderFieldsForRefreshSteps } from "../utils/fields"
-import { refreshDraftOrderAdjustmentsWorkflow } from "./refresh-draft-order-adjustments"
 import { acquireLockStep, releaseLockStep } from "../../locking"
+import { computeDraftOrderAdjustmentsWorkflow } from "./compute-draft-order-adjustments"

 export const updateDraftOrderShippingMethodWorkflowId =
  "update-draft-order-shipping-method"
@@ -144,11 +140,9 @@ export const updateDraftOrderShippingMethodWorkflow = createWorkflow(
      appliedPromoCodes,
      (appliedPromoCodes) => appliedPromoCodes.length > 0
    ).then(() => {
-      refreshDraftOrderAdjustmentsWorkflow.runAsStep({
+      computeDraftOrderAdjustmentsWorkflow.runAsStep({
        input: {
-          order: refetchedOrder,
-          promo_codes: appliedPromoCodes,
-          action: PromotionActions.REPLACE,
+          order_id: input.order_id,
        },
      })
    })
@@ -129,7 +129,7 @@ export const createOrUpdateOrderPaymentCollectionWorkflow = createWorkflow(
        return (
          !!existingPaymentCollection?.id &&
          !shouldRecreate &&
-          MathBN.gt(amountPending, 0)
+          MathBN.gte(amountPending, 0)
        )
      }
    ).then(() => {
@@ -4,6 +4,7 @@ import {
  OrderExchangeDTO,
  OrderPreviewDTO,
  OrderWorkflow,
+  PromotionDTO,
 } from "@medusajs/framework/types"
 import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
 import {
@@ -21,6 +22,7 @@ import {
 } from "../../utils/order-validation"
 import { addOrderLineItemsWorkflow } from "../add-line-items"
 import { createOrderChangeActionsWorkflow } from "../create-order-change-actions"
+import { computeAdjustmentsForPreviewWorkflow } from "../order-edit/compute-adjustments-for-preview"
 import { updateOrderTaxLinesWorkflow } from "../update-tax-lines"
 import { refreshExchangeShippingWorkflow } from "./refresh-shipping"

@@ -123,7 +125,14 @@ export const orderExchangeAddNewItemWorkflow = createWorkflow(

    const order: OrderDTO = useRemoteQueryStep({
      entry_point: "orders",
-      fields: ["id", "status", "canceled_at", "items.*"],
+      fields: [
+        "id",
+        "status",
+        "canceled_at",
+        "currency_code",
+        "items.*",
+        "promotions.*",
+      ],
      variables: { id: orderExchange.order_id },
      list: false,
      throw_if_key_not_found: true,
@@ -131,7 +140,7 @@ export const orderExchangeAddNewItemWorkflow = createWorkflow(

    const orderChange: OrderChangeDTO = useRemoteQueryStep({
      entry_point: "order_change",
-      fields: ["id", "status"],
+      fields: ["id", "status", "version"],
      variables: {
        filters: {
          order_id: orderExchange.order_id,
@@ -192,6 +201,21 @@ export const orderExchangeAddNewItemWorkflow = createWorkflow(
      input: orderChangeActionInput,
    })

+    const orderWithPromotions = transform({ order }, ({ order }) => {
+      return {
+        ...order,
+        promotions: (order as any).promotions ?? [],
+      } as OrderDTO & { promotions: PromotionDTO[] }
+    })
+
+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order: orderWithPromotions,
+        orderChange,
+        exchange_id: orderExchange.id,
+      },
+    })
+
    const refreshArgs = transform(
      { orderChange, orderExchange },
      ({ orderChange, orderExchange }) => {
@@ -4,6 +4,7 @@ import {
  OrderExchangeDTO,
  OrderPreviewDTO,
  OrderWorkflow,
+  PromotionDTO,
  ReturnDTO,
 } from "@medusajs/framework/types"
 import {
@@ -32,6 +33,7 @@ import {
  throwIfOrderChangeIsNotActive,
 } from "../../utils/order-validation"
 import { createOrderChangeActionsWorkflow } from "../create-order-change-actions"
+import { computeAdjustmentsForPreviewWorkflow } from "../order-edit/compute-adjustments-for-preview"
 import { refreshExchangeShippingWorkflow } from "./refresh-shipping"

 /**
@@ -178,10 +180,12 @@ export const orderExchangeRequestItemReturnWorkflow = createWorkflow(
      fields: [
        "id",
        "status",
+        "currency_code",
        "items.*",
        "items.variant.manage_inventory",
        "items.variant.inventory_items.inventory_item_id",
        "items.variant.inventory_items.inventory.location_levels.location_id",
+        "promotions.*",
      ],
      variables: { id: orderExchange.order_id },
      list: false,
@@ -190,7 +194,7 @@ export const orderExchangeRequestItemReturnWorkflow = createWorkflow(

    const orderChange: OrderChangeDTO = useRemoteQueryStep({
      entry_point: "order_change",
-      fields: ["id", "status"],
+      fields: ["id", "status", "version"],
      variables: {
        filters: {
          order_id: orderExchange.order_id,
@@ -306,6 +310,21 @@ export const orderExchangeRequestItemReturnWorkflow = createWorkflow(
      input: orderChangeActionInput,
    })

+    const orderWithPromotions = transform({ order }, ({ order }) => {
+      return {
+        ...order,
+        promotions: (order as any).promotions ?? [],
+      } as OrderDTO & { promotions: PromotionDTO[] }
+    })
+
+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order: orderWithPromotions,
+        orderChange,
+        exchange_id: orderExchange.id,
+      },
+    })
+
    const refreshArgs = transform(
      { orderChange, orderExchange },
      ({ orderChange, orderExchange }) => {
@@ -30,7 +30,6 @@ export * from "./decline-order-change"
 export * from "./delete-order-change"
 export * from "./delete-order-change-actions"
 export * from "./delete-order-payment-collection"
-export * from "./fetch-shipping-option"
 export * from "./exchange/begin-order-exchange"
 export * from "./exchange/cancel-begin-order-exchange"
 export * from "./exchange/cancel-exchange"
@@ -42,13 +41,16 @@ export * from "./exchange/remove-exchange-item-action"
 export * from "./exchange/remove-exchange-shipping-method"
 export * from "./exchange/update-exchange-add-item"
 export * from "./exchange/update-exchange-shipping-method"
+export * from "./fetch-shipping-option"
 export * from "./get-order-detail"
 export * from "./get-orders-list"
+export * from "./list-shipping-options-for-order"
 export * from "./mark-order-fulfillment-as-delivered"
 export * from "./mark-payment-collection-as-paid"
 export * from "./maybe-refresh-shipping-methods"
 export * from "./order-edit/begin-order-edit"
 export * from "./order-edit/cancel-begin-order-edit"
+export * from "./order-edit/compute-adjustments-for-preview"
 export * from "./order-edit/confirm-order-edit-request"
 export * from "./order-edit/create-order-edit-shipping-method"
 export * from "./order-edit/order-edit-add-new-item"
@@ -87,4 +89,3 @@ export * from "./update-order"
 export * from "./update-order-change-actions"
 export * from "./update-order-changes"
 export * from "./update-tax-lines"
-export * from "./list-shipping-options-for-order"
@@ -104,6 +104,8 @@ export const beginOrderEditOrderWorkflow = createWorkflow(
      }
    })

-    return new WorkflowResponse(createOrderChangeStep(orderChangeInput))
+    const orderChange = createOrderChangeStep(orderChangeInput)
+
+    return new WorkflowResponse(orderChange)
  }
 )
@@ -0,0 +1,163 @@
+import {
+  ComputeActionContext,
+  OrderChangeDTO,
+  OrderDTO,
+  PromotionDTO,
+} from "@medusajs/framework/types"
+import { ChangeActionType } from "@medusajs/framework/utils"
+import {
+  createWorkflow,
+  transform,
+  when,
+  WorkflowData,
+} from "@medusajs/framework/workflows-sdk"
+import {
+  getActionsToComputeFromPromotionsStep,
+  prepareAdjustmentsFromPromotionActionsStep,
+} from "../../../cart"
+import { previewOrderChangeStep } from "../../steps/preview-order-change"
+import { createOrderChangeActionsWorkflow } from "../create-order-change-actions"
+
+/**
+ * The data to compute adjustments for an order edit, exchange, claim, or return.
+ */
+export type ComputeAdjustmentsForPreviewWorkflowInput = {
+  /**
+   * The order's details.
+   */
+  order: OrderDTO & { promotions: PromotionDTO[] }
+  /**
+   * The order change's details.
+   */
+  orderChange: OrderChangeDTO
+  /**
+   * Optional exchange ID to include in the order change action.
+   */
+  exchange_id?: string
+  /**
+   * Optional claim ID to include in the order change action.
+   */
+  claim_id?: string
+  /**
+   * Optional return ID to include in the order change action.
+   */
+  return_id?: string
+}
+
+export const computeAdjustmentsForPreviewWorkflowId =
+  "compute-adjustments-for-preview"
+/**
+ * This workflow computes adjustments for an order edit, exchange, claim, or return.
+ * It's used by the [Add Items to Order Edit Admin API Route](https://docs.medusajs.com/api/admin#order-edits_postordereditsiditems),
+ * [Add Outbound Items Admin API Route](https://docs.medusajs.com/api/admin#exchanges_postexchangesidoutbounditems),
+ * and [Add Inbound Items Admin API Route](https://docs.medusajs.com/api/admin#exchanges_postexchangesidinbounditems).
+ *
+ * You can use this workflow within your customizations or your own custom workflows, allowing you to compute adjustments
+ * in your custom flows.
+ *
+ * @example
+ * const { result } = await computeAdjustmentsForPreviewWorkflow(container)
+ * .run({
+ *   input: {
+ *     order: {
+ *       id: "order_123",
+ *       // other order details...
+ *     },
+ *     orderChange: {
+ *       id: "orch_123",
+ *       // other order change details...
+ *     },
+ *     exchange_id: "exchange_123", // optional, for exchanges
+ *   }
+ * })
+ *
+ * @summary
+ *
+ * Compute adjustments for an order edit, exchange, claim, or return.
+ */
+export const computeAdjustmentsForPreviewWorkflow = createWorkflow(
+  computeAdjustmentsForPreviewWorkflowId,
+  function (input: WorkflowData<ComputeAdjustmentsForPreviewWorkflowInput>) {
+    const previewedOrder = previewOrderChangeStep(input.order.id)
+
+    when({ order: input.order }, ({ order }) => !!order.promotions.length).then(
+      () => {
+        const actionsToComputeItemsInput = transform(
+          { previewedOrder, order: input.order },
+          ({ previewedOrder, order }) => {
+            return {
+              currency_code: order.currency_code,
+              items: previewedOrder.items.map((item) => ({
+                ...item,
+                // Buy-Get promotions rely on the product ID, so we need to manually set it before refreshing adjustments
+                product: { id: item.product_id },
+              })),
+            } as ComputeActionContext
+          }
+        )
+
+        const orderPromotions = transform(
+          { order: input.order },
+          ({ order }) => {
+            return order.promotions
+              .map((p) => p.code)
+              .filter((p) => p !== undefined)
+          }
+        )
+
+        const actions = getActionsToComputeFromPromotionsStep({
+          computeActionContext: actionsToComputeItemsInput,
+          promotionCodesToApply: orderPromotions,
+        })
+
+        const { lineItemAdjustmentsToCreate } =
+          prepareAdjustmentsFromPromotionActionsStep({ actions })
+
+        const orderChangeActionAdjustmentsInput = transform(
+          {
+            order: input.order,
+            previewedOrder,
+            orderChange: input.orderChange,
+            lineItemAdjustmentsToCreate,
+            exchangeId: input.exchange_id,
+            claimId: input.claim_id,
+            returnId: input.return_id,
+          },
+          ({
+            order,
+            previewedOrder,
+            orderChange,
+            lineItemAdjustmentsToCreate,
+            exchangeId,
+            claimId,
+            returnId,
+          }) => {
+            return previewedOrder.items.map((item) => {
+              const itemAdjustments = lineItemAdjustmentsToCreate.filter(
+                (adjustment) => adjustment.item_id === item.id
+              )
+
+              return {
+                order_change_id: orderChange.id,
+                order_id: order.id,
+                ...(exchangeId && { exchange_id: exchangeId }),
+                ...(claimId && { claim_id: claimId }),
+                ...(returnId && { return_id: returnId }),
+                version: orderChange.version,
+                action: ChangeActionType.ITEM_ADJUSTMENTS_REPLACE,
+                details: {
+                  reference_id: item.id,
+                  adjustments: itemAdjustments,
+                },
+              }
+            })
+          }
+        )
+
+        createOrderChangeActionsWorkflow
+          .runAsStep({ input: orderChangeActionAdjustmentsInput })
+          .config({ name: "order-change-action-adjustments-input" })
+      }
+    )
+  }
+)
@@ -6,26 +6,23 @@ import {
 } from "@medusajs/framework/types"
 import {
  ChangeActionType,
+  deduplicate,
  MathBN,
  OrderChangeStatus,
  OrderEditWorkflowEvents,
 } from "@medusajs/framework/utils"
 import {
-  WorkflowResponse,
  createStep,
  createWorkflow,
  transform,
+  WorkflowResponse,
 } from "@medusajs/framework/workflows-sdk"
 import { reserveInventoryStep } from "../../../cart/steps/reserve-inventory"
 import {
  prepareConfirmInventoryInput,
  requiredOrderFieldsForInventoryConfirmation,
 } from "../../../cart/utils/prepare-confirm-inventory-input"
-import {
-  emitEventStep,
-  useQueryGraphStep,
-  useRemoteQueryStep,
-} from "../../../common"
+import { emitEventStep, useQueryGraphStep } from "../../../common"
 import { deleteReservationsByLineItemsStep } from "../../../reservation"
 import { previewOrderChangeStep } from "../../steps"
 import { confirmOrderChanges } from "../../steps/confirm-order-changes"
@@ -176,22 +173,27 @@ export const confirmOrderEditRequestWorkflow = createWorkflow(
      confirmed_by: input.confirmed_by,
    })

-    const orderItems = useRemoteQueryStep({
-      entry_point: "order",
-      fields: requiredOrderFieldsForInventoryConfirmation,
-      variables: { id: input.order_id },
-      list: false,
-      throw_if_key_not_found: true,
+    const { data: refreshedOrder } = useQueryGraphStep({
+      entity: "order",
+      fields: deduplicate([
+        ...requiredOrderFieldsForInventoryConfirmation,
+        ...fieldsToRefreshOrderEdit,
+      ]),
+      filters: { id: input.order_id },
+      options: {
+        throwIfKeyNotFound: true,
+        isList: false,
+      },
    }).config({ name: "order-items-query" })

    const { variants, items, toRemoveReservationLineItemIds } = transform(
-      { orderItems, previousOrderItems: order.items, orderPreview },
-      ({ orderItems, previousOrderItems, orderPreview }) => {
+      { refreshedOrder, previousOrderItems: order.items, orderPreview },
+      ({ refreshedOrder, previousOrderItems, orderPreview }) => {
        const allItems: any[] = []
        const allVariants: any[] = []

        const previousItemIds = (previousOrderItems || []).map(({ id }) => id)
-        const currentItemIds = orderItems.items.map(({ id }) => id)
+        const currentItemIds = refreshedOrder.items.map(({ id }) => id)

        const removedItemIds = previousItemIds.filter(
          (id) => !currentItemIds.includes(id)
@@ -199,7 +201,7 @@ export const confirmOrderEditRequestWorkflow = createWorkflow(

        const updatedItemIds: string[] = []

-        orderItems.items.forEach((ordItem) => {
+        refreshedOrder.items.forEach((ordItem) => {
          const itemAction = orderPreview.items?.find(
            (item) =>
              item.id === ordItem.id &&
@@ -214,13 +216,6 @@ export const confirmOrderEditRequestWorkflow = createWorkflow(
            return
          }

-          const unitPrice: BigNumberInput =
-            itemAction.raw_unit_price ?? itemAction.unit_price
-
-          const compareAtUnitPrice: BigNumberInput | undefined =
-            itemAction.raw_compare_at_unit_price ??
-            itemAction.compare_at_unit_price
-
          const updateAction = itemAction.actions!.find(
            (a) => a.action === ChangeActionType.ITEM_UPDATE
          )
@@ -241,8 +236,6 @@ export const confirmOrderEditRequestWorkflow = createWorkflow(
            id: ordItem.id,
            variant_id: ordItem.variant_id,
            quantity: reservationQuantity,
-            unit_price: unitPrice,
-            compare_at_unit_price: compareAtUnitPrice,
          })
          allVariants.push(ordItem.variant)
        })
@@ -261,7 +254,7 @@ export const confirmOrderEditRequestWorkflow = createWorkflow(
    const formatedInventoryItems = transform(
      {
        input: {
-          sales_channel_id: (orderItems as any).sales_channel_id,
+          sales_channel_id: (refreshedOrder as any).sales_channel_id,
          variants,
          items,
        },
@@ -4,16 +4,13 @@ import {
  OrderPreviewDTO,
  OrderWorkflow,
 } from "@medusajs/framework/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
 import {
-  ChangeActionType,
-  OrderChangeStatus
-} from "@medusajs/framework/utils"
-import {
-  WorkflowData,
-  WorkflowResponse,
  createStep,
  createWorkflow,
  transform,
+  WorkflowData,
+  WorkflowResponse,
 } from "@medusajs/framework/workflows-sdk"
 import { useQueryGraphStep } from "../../../common"
 import { previewOrderChangeStep } from "../../steps/preview-order-change"
@@ -25,6 +22,7 @@ import { addOrderLineItemsWorkflow } from "../add-line-items"
 import { createOrderChangeActionsWorkflow } from "../create-order-change-actions"
 import { updateOrderTaxLinesWorkflow } from "../update-tax-lines"
 import { fieldsToRefreshOrderEdit } from "./utils/fields"
+import { computeAdjustmentsForPreviewWorkflow } from "./compute-adjustments-for-preview"

 /**
 * The data to validate that new items can be added to an order edit.
@@ -158,7 +156,12 @@ export const orderEditAddNewItemWorkflow = createWorkflow(
    })

    const orderChangeActionInput = transform(
-      { order, orderChange, items: input.items, lineItems },
+      {
+        order,
+        orderChange,
+        items: input.items,
+        lineItems,
+      },
      ({ order, orderChange, items, lineItems }) => {
        return items.map((item, index) => ({
          order_change_id: orderChange.id,
@@ -183,6 +186,13 @@ export const orderEditAddNewItemWorkflow = createWorkflow(
      input: orderChangeActionInput,
    })

+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order,
+        orderChange,
+      },
+    })
+
    return new WorkflowResponse(previewOrderChangeStep(input.order_id))
  }
 )
@@ -11,11 +11,11 @@ import {
  OrderChangeStatus,
 } from "@medusajs/framework/utils"
 import {
-  WorkflowData,
-  WorkflowResponse,
  createStep,
  createWorkflow,
  transform,
+  WorkflowData,
+  WorkflowResponse,
 } from "@medusajs/framework/workflows-sdk"
 import { useQueryGraphStep } from "../../../common"
 import { previewOrderChangeStep } from "../../steps/preview-order-change"
@@ -24,6 +24,7 @@ import {
  throwIfOrderChangeIsNotActive,
 } from "../../utils/order-validation"
 import { createOrderChangeActionsWorkflow } from "../create-order-change-actions"
+import { computeAdjustmentsForPreviewWorkflow } from "./compute-adjustments-for-preview"
 import { fieldsToRefreshOrderEdit } from "./utils/fields"

 /**
@@ -80,6 +81,10 @@ export const orderEditUpdateItemQuantityWorkflowId =
 * This workflow updates the quantity of an existing item in an order's edit. It's used by the
 * [Update Order Item Quantity Admin API Route](https://docs.medusajs.com/api/admin#order-edits_postordereditsiditemsitemitem_id).
 *
+ * This workflow is different from the `updateOrderEditItemQuantityWorkflow` workflow in that this should be used
+ * when the item to update was part of the original order before the edit. The other workflow is for items
+ * that were added to the order as part of the edit.
+ *
 * You can also use this workflow to remove an item from an order by setting its quantity to `0`.
 *
 * You can use this workflow within your customizations or your own custom workflows, allowing you to update the quantity of an existing
@@ -143,9 +148,13 @@ export const orderEditUpdateItemQuantityWorkflow = createWorkflow(
    })

    const orderChangeActionInput = transform(
-      { order, orderChange, items: input.items },
+      {
+        order,
+        orderChange,
+        items: input.items,
+      },
      ({ order, orderChange, items }) => {
-        return items.map((item) => {
+        const itemsUpdates = items.map((item) => {
          const existing = order?.items?.find(
            (exItem) => exItem.id === item.id
          )!
@@ -169,6 +178,8 @@ export const orderEditUpdateItemQuantityWorkflow = createWorkflow(
            },
          }
        })
+
+        return [...itemsUpdates]
      }
    )

@@ -176,6 +187,13 @@ export const orderEditUpdateItemQuantityWorkflow = createWorkflow(
      input: orderChangeActionInput,
    })

+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order,
+        orderChange,
+      },
+    })
+
    return new WorkflowResponse(previewOrderChangeStep(input.order_id))
  }
 )
@@ -5,10 +5,7 @@ import {
  OrderPreviewDTO,
  OrderWorkflow,
 } from "@medusajs/framework/types"
-import {
-  ChangeActionType,
-  OrderChangeStatus
-} from "@medusajs/framework/utils"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/framework/utils"
 import {
  WorkflowData,
  WorkflowResponse,
@@ -25,6 +22,7 @@ import {
  throwIfIsCancelled,
  throwIfOrderChangeIsNotActive,
 } from "../../utils/order-validation"
+import { computeAdjustmentsForPreviewWorkflow } from "./compute-adjustments-for-preview"
 import { fieldsToRefreshOrderEdit } from "./utils/fields"

 /**
@@ -167,6 +165,13 @@ export const removeItemOrderEditActionWorkflow = createWorkflow(

    deleteOrderChangeActionsStep({ ids: [input.action_id] })

+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order,
+        orderChange,
+      },
+    })
+
    return new WorkflowResponse(previewOrderChangeStep(order.id))
  }
 )
@@ -22,6 +22,7 @@ import {
  throwIfIsCancelled,
  throwIfOrderChangeIsNotActive,
 } from "../../utils/order-validation"
+import { computeAdjustmentsForPreviewWorkflow } from "./compute-adjustments-for-preview"
 import { fieldsToRefreshOrderEdit } from "./utils/fields"

 /**
@@ -185,6 +186,13 @@ export const updateOrderEditAddItemWorkflow = createWorkflow(

    updateOrderChangeActionsStep([updateData])

+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order,
+        orderChange,
+      },
+    })
+
    return new WorkflowResponse(previewOrderChangeStep(order.id))
  }
 )
@@ -22,6 +22,7 @@ import {
  throwIfIsCancelled,
  throwIfOrderChangeIsNotActive,
 } from "../../utils/order-validation"
+import { computeAdjustmentsForPreviewWorkflow } from "./compute-adjustments-for-preview"
 import { fieldsToRefreshOrderEdit } from "./utils/fields"

 /**
@@ -105,6 +106,9 @@ export const updateOrderEditItemQuantityWorkflowId =
  "update-order-edit-update-quantity"
 /**
 * This workflow updates an existing order item that was previously added to the order edit.
+ * It is different from the `orderEditUpdateItemQuantityWorkflow` workflow in that this should be used
+ * when the item to update was added as part of the order edit. The other workflow is for items
+ * that were already in the order before the edit.
 *
 * You can use this workflow within your customizations or your own custom workflows, allowing you to update the quantity
 * of an existing item in an order edit in your custom flows.
@@ -185,6 +189,13 @@ export const updateOrderEditItemQuantityWorkflow = createWorkflow(

    updateOrderChangeActionsStep([updateData])

+    computeAdjustmentsForPreviewWorkflow.runAsStep({
+      input: {
+        order,
+        orderChange,
+      },
+    })
+
    return new WorkflowResponse(previewOrderChangeStep(order.id))
  }
 )
@@ -4,8 +4,13 @@ export const fieldsToRefreshOrderEdit = [
  "version",
  "currency_code",
  "canceled_at",
-  "items.*",
-  "items.product.id",
  "promotions.*",
+  "subtotal",
+  "items.*",
+  "items.subtotal",
+  "items.product.id",
+  "items.adjustments.*",
+  "shipping_methods.*",
+  "shipping_methods.adjustments.*",
  "shipping_address.*",
 ]
@@ -4,6 +4,7 @@ import {
  transform,
  when,
  WorkflowData,
+  WorkflowResponse,
 } from "@medusajs/framework/workflows-sdk"
 import { useQueryGraphStep } from "../../common"
 import { getItemTaxLinesStep } from "../../tax/steps/get-item-tax-lines"
@@ -179,9 +180,7 @@ export const updateOrderTaxLinesWorkflowId = "update-order-tax-lines"
 */
 export const updateOrderTaxLinesWorkflow = createWorkflow(
  updateOrderTaxLinesWorkflowId,
-  (
-    input: WorkflowData<UpdateOrderTaxLinesWorkflowInput>
-  ): WorkflowData<void> => {
+  (input: WorkflowData<UpdateOrderTaxLinesWorkflowInput>) => {
    const isFullOrder = transform(input, (data) => {
      return !data.item_ids && !data.shipping_method_ids
    })
@@ -209,9 +208,13 @@ export const updateOrderTaxLinesWorkflow = createWorkflow(
      return orderLineItems
    })

-    const shippingMethods = when("get-order-shipping-methods", { input }, ({ input }) => {
-      return input.shipping_method_ids!?.length > 0
-    }).then(() => {
+    const shippingMethods = when(
+      "get-order-shipping-methods",
+      { input },
+      ({ input }) => {
+        return input.shipping_method_ids!?.length > 0
+      }
+    ).then(() => {
      const { data: orderShippingMethods } = useQueryGraphStep({
        entity: "order_shipping_method",
        filters: { id: input.shipping_method_ids },
@@ -250,5 +253,10 @@ export const updateOrderTaxLinesWorkflow = createWorkflow(
      item_tax_lines: taxLineItems.lineItemTaxLines,
      shipping_tax_lines: taxLineItems.shippingMethodsTaxLines,
    })
+
+    return new WorkflowResponse({
+      itemTaxLines: taxLineItems.lineItemTaxLines,
+      shippingTaxLines: taxLineItems.shippingMethodsTaxLines,
+    })
  }
 )