chore(core-flows,medusa): order claims (#8271)

packages/core/core-flows/src/order/steps/delete-claims.ts

@@ -0,0 +1,28 @@
+import { IOrderModuleService } from "@medusajs/types"
+import { ModuleRegistrationName } from "@medusajs/utils"
+import { createStep, StepResponse } from "@medusajs/workflows-sdk"
+
+export const deleteClaimsStepId = "delete-claims"
+export const deleteClaimsStep = createStep(
+  deleteClaimsStepId,
+  async (data: { ids: string[] }, { container }) => {
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const deleted = await service.softDeleteOrderClaims(data.ids)
+
+    return new StepResponse(deleted, data.ids)
+  },
+  async (ids, { container }) => {
+    if (!ids) {
+      return
+    }
+
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    await service.restoreOrderClaims(ids)
+  }
+)

packages/core/core-flows/src/order/steps/delete-returns.ts

@@ -10,12 +10,14 @@ export const deleteReturnsStep = createStep(
       ModuleRegistrationName.ORDER
     )
 
-    const deleted = await service.softDeleteReturns(data.ids)
+    const ids = data.ids.filter(Boolean)
+
+    const deleted = ids.length ? await service.softDeleteReturns(ids) : []
 
     return new StepResponse(deleted, data.ids)
   },
   async (ids, { container }) => {
-    if (!ids) {
+    if (!ids?.length) {
       return
     }
 

packages/core/core-flows/src/order/steps/index.ts

@@ -14,11 +14,12 @@ export * from "./create-order-change-actions"
 export * from "./create-orders"
 export * from "./create-returns"
 export * from "./decline-order-change"
+export * from "./delete-claims"
 export * from "./delete-line-items"
 export * from "./delete-order-change-actions"
 export * from "./delete-order-changes"
 export * from "./delete-order-shipping-methods"
-export * from "./delete-return"
+export * from "./delete-returns"
 export * from "./get-item-tax-lines"
 export * from "./preview-order-change"
 export * from "./register-fulfillment"
@@ -27,5 +28,6 @@ export * from "./set-tax-lines-for-items"
 export * from "./update-order-change-actions"
 export * from "./update-order-exchanges"
 export * from "./update-return-items"
+export * from "./update-returns"
 export * from "./update-shipping-methods"
 export * from "./update-tax-lines"

packages/core/core-flows/src/order/steps/update-returns.ts

@@ -0,0 +1,35 @@
+import { UpdateReturnDTO } from "@medusajs/types"
+import {
+  ModuleRegistrationName,
+  getSelectsAndRelationsFromObjectArray,
+} from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+export const updateReturnsStepId = "update-returns"
+export const updateReturnsStep = createStep(
+  updateReturnsStepId,
+  async (data: UpdateReturnDTO[], { container }) => {
+    const service = container.resolve(ModuleRegistrationName.ORDER) as any
+
+    const { selects, relations } = getSelectsAndRelationsFromObjectArray(data, {
+      objectFields: ["metadata"],
+    })
+    const dataBeforeUpdate = await service.listReturns(
+      { id: data.map((d) => d.id) },
+      { relations, select: selects }
+    )
+
+    const updated = await service.updateReturns(data)
+
+    return new StepResponse(updated, dataBeforeUpdate)
+  },
+  async (dataBeforeUpdate, { container }) => {
+    if (!dataBeforeUpdate?.length) {
+      return
+    }
+
+    const service = container.resolve(ModuleRegistrationName.ORDER) as any
+
+    await service.updateReturns(dataBeforeUpdate)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/begin-order-claim.ts

@@ -8,12 +8,12 @@ import {
 import { useRemoteQueryStep } from "../../../common"
 import { createOrderClaimsStep } from "../../steps/create-claims"
 import { createOrderChangeStep } from "../../steps/create-order-change"
-import { throwIfOrderIsCancelled } from "../../utils/order-validation"
+import { throwIfIsCancelled } from "../../utils/order-validation"
 
 const validationStep = createStep(
   "begin-claim-order-validation",
   async function ({ order }: { order: OrderDTO }) {
-    throwIfOrderIsCancelled({ order })
+    throwIfIsCancelled(order, "Order")
   }
 )
 

packages/core/core-flows/src/order/workflows/claim/cancel-begin-order-claim.ts

@@ -0,0 +1,94 @@
+import { OrderChangeDTO, OrderClaimDTO, OrderDTO } from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  parallelize,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import {
+  deleteClaimsStep,
+  deleteOrderChangesStep,
+  deleteOrderShippingMethods,
+  deleteReturnsStep,
+} from "../../steps"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+type WorkflowInput = {
+  claim_id: string
+}
+
+const validationStep = createStep(
+  "validate-cancel-begin-order-claim",
+  async function ({
+    order,
+    orderChange,
+    orderClaim,
+  }: {
+    order: OrderDTO
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+  }
+)
+
+export const cancelBeginOrderClaimWorkflowId = "cancel-begin-order-claim"
+export const cancelBeginOrderClaimWorkflow = createWorkflow(
+  cancelBeginOrderClaimWorkflowId,
+  function (input: WorkflowInput): WorkflowData<void> {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "return_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "version", "canceled_at"],
+      variables: { id: orderClaim.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: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ order, orderClaim, orderChange })
+
+    const shippingToRemove = transform(
+      { orderChange, input },
+      ({ orderChange, input }) => {
+        return (orderChange.actions ?? [])
+          .filter((a) => a.action === ChangeActionType.SHIPPING_ADD)
+          .map(({ id }) => id)
+      }
+    )
+
+    parallelize(
+      deleteReturnsStep({ ids: [orderClaim.return_id!] }),
+      deleteClaimsStep({ ids: [orderClaim.id] }),
+      deleteOrderChangesStep({ ids: [orderChange.id] }),
+      deleteOrderShippingMethods({ ids: shippingToRemove })
+    )
+  }
+)

packages/core/core-flows/src/order/workflows/claim/claim-add-new-item.ts

@@ -17,7 +17,6 @@ import { previewOrderChangeStep } from "../../steps/preview-order-change"
 import {
   throwIfIsCancelled,
   throwIfOrderChangeIsNotActive,
-  throwIfOrderIsCancelled,
 } from "../../utils/order-validation"
 import { addOrderLineItemsWorkflow } from "../add-line-items"
 
@@ -32,7 +31,7 @@ const validationStep = createStep(
     orderClaim: OrderClaimDTO
     orderChange: OrderChangeDTO
   }) {
-    throwIfOrderIsCancelled({ order })
+    throwIfIsCancelled(order, "Order")
     throwIfIsCancelled(orderClaim, "Claim")
     throwIfOrderChangeIsNotActive({ orderChange })
   }

packages/core/core-flows/src/order/workflows/claim/claim-item.ts

@@ -0,0 +1,104 @@
+import {
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+  OrderWorkflow,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import { createOrderChangeActionsStep } from "../../steps/create-order-change-actions"
+import { previewOrderChangeStep } from "../../steps/preview-order-change"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "claim-item-validation",
+  async function ({
+    order,
+    orderChange,
+    orderClaim,
+  }: {
+    order: OrderDTO
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+  }
+)
+
+export const orderClaimItemWorkflowId = "claim-item"
+export const orderClaimItemWorkflow = createWorkflow(
+  orderClaimItemWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.OrderClaimItemWorkflowInput>
+  ): WorkflowData<OrderDTO> {
+    const orderClaim = useRemoteQueryStep({
+      entry_point: "order_claim",
+      fields: ["id", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    }).config({ name: "claim-query" })
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "canceled_at", "items.*"],
+      variables: { id: orderClaim.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"],
+      variables: {
+        filters: {
+          order_id: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({
+      order,
+      orderClaim,
+      orderChange,
+    })
+
+    const orderChangeActionInput = transform(
+      { order, orderChange, orderClaim, items: input.items },
+      ({ order, orderChange, orderClaim, items }) => {
+        return items.map((item, index) => ({
+          order_change_id: orderChange.id,
+          order_id: order.id,
+          claim_id: orderClaim.id,
+          version: orderChange.version,
+          action: ChangeActionType.WRITE_OFF_ITEM,
+          internal_note: item.internal_note,
+          reference: "order_claim",
+          reference_id: orderClaim.id,
+          details: {
+            reference_id: item.id,
+            quantity: item.quantity,
+          },
+        }))
+      }
+    )
+
+    createOrderChangeActionsStep(orderChangeActionInput)
+
+    return previewOrderChangeStep(orderClaim.order_id)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/claim-request-item-return.ts

@@ -7,11 +7,11 @@ import {
 } from "@medusajs/types"
 import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
 import {
+  WorkflowData,
   createStep,
   createWorkflow,
   transform,
   when,
-  WorkflowData,
 } from "@medusajs/workflows-sdk"
 import { useRemoteQueryStep } from "../../../common"
 import { createOrderChangeActionsStep } from "../../steps/create-order-change-actions"
@@ -22,7 +22,6 @@ import {
   throwIfIsCancelled,
   throwIfItemsDoesNotExistsInOrder,
   throwIfOrderChangeIsNotActive,
-  throwIfOrderIsCancelled,
 } from "../../utils/order-validation"
 
 const validationStep = createStep(
@@ -40,7 +39,7 @@ const validationStep = createStep(
     orderChange: OrderChangeDTO
     items: OrderWorkflow.OrderClaimRequestItemReturnWorkflowInput["items"]
   }) {
-    throwIfOrderIsCancelled({ order })
+    throwIfIsCancelled(order, "Order")
     throwIfIsCancelled(orderClaim, "Claim")
     throwIfIsCancelled(orderReturn, "Return")
     throwIfOrderChangeIsNotActive({ orderChange })

packages/core/core-flows/src/order/workflows/claim/create-claim-shipping-method.ts

@@ -0,0 +1,169 @@
+import {
+  BigNumberInput,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import { previewOrderChangeStep } from "../../steps"
+import { createOrderChangeActionsStep } from "../../steps/create-order-change-actions"
+import { createOrderShippingMethods } from "../../steps/create-order-shipping-methods"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "validate-create-claim-shipping-method",
+  async function ({
+    order,
+    orderChange,
+    orderClaim,
+  }: {
+    order: OrderDTO
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+  }
+)
+
+export const createClaimShippingMethodWorkflowId =
+  "create-claim-shipping-method"
+export const createClaimShippingMethodWorkflow = createWorkflow(
+  createClaimShippingMethodWorkflowId,
+  function (input: {
+    return_id?: string
+    claim_id?: string
+    shipping_option_id: string
+    custom_price?: BigNumberInput
+  }): WorkflowData<OrderDTO> {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "currency_code", "canceled_at"],
+      variables: { id: orderClaim.order_id },
+      list: false,
+      throw_if_key_not_found: true,
+    }).config({ name: "order-query" })
+
+    const shippingOptions = useRemoteQueryStep({
+      entry_point: "shipping_option",
+      fields: [
+        "id",
+        "name",
+        "calculated_price.calculated_amount",
+        "calculated_price.is_calculated_price_tax_inclusive",
+      ],
+      variables: {
+        id: input.shipping_option_id,
+        calculated_price: {
+          context: { currency_code: order.currency_code },
+        },
+      },
+    }).config({ name: "fetch-shipping-option" })
+
+    const orderChange: OrderChangeDTO = useRemoteQueryStep({
+      entry_point: "order_change",
+      fields: ["id", "status", "version"],
+      variables: {
+        filters: {
+          order_id: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ order, orderClaim, orderChange })
+
+    const shippingMethodInput = transform(
+      {
+        orderClaim,
+        shippingOptions,
+        customPrice: input.custom_price,
+        orderChange,
+        input,
+      },
+      (data) => {
+        const option = data.shippingOptions[0]
+        const orderChange = data.orderChange
+
+        return {
+          shipping_option_id: option.id,
+          amount: data.customPrice ?? option.calculated_price.calculated_amount,
+          is_tax_inclusive:
+            !!option.calculated_price.is_calculated_price_tax_inclusive,
+          data: option.data ?? {},
+          name: option.name,
+          version: orderChange.version,
+          order_id: data.orderClaim.order_id,
+          return_id: data.orderClaim.id,
+          claim_id: data.input.claim_id,
+        }
+      }
+    )
+
+    const createdMethods = createOrderShippingMethods({
+      shipping_methods: [shippingMethodInput],
+    })
+
+    const orderChangeActionInput = transform(
+      {
+        order,
+        orderClaim,
+        shippingOptions,
+        createdMethods,
+        customPrice: input.custom_price,
+        orderChange,
+        input,
+      },
+      ({
+        shippingOptions,
+        orderClaim,
+        order,
+        createdMethods,
+        customPrice,
+        orderChange,
+        input,
+      }) => {
+        const shippingOption = shippingOptions[0]
+        const createdMethod = createdMethods[0]
+        const methodPrice =
+          customPrice ?? shippingOption.calculated_price.calculated_amount
+
+        return {
+          action: ChangeActionType.SHIPPING_ADD,
+          reference: "order_shipping_method",
+          order_change_id: orderChange.id,
+          reference_id: createdMethod.id,
+          amount: methodPrice,
+          order_id: order.id,
+          return_id: orderClaim.id,
+          claim_id: input.claim_id,
+        }
+      }
+    )
+
+    createOrderChangeActionsStep([orderChangeActionInput])
+
+    return previewOrderChangeStep(order.id)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/remove-claim-item-action.ts

@@ -0,0 +1,96 @@
+import {
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+  OrderWorkflow,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import {
+  deleteOrderChangeActionsStep,
+  previewOrderChangeStep,
+} from "../../steps"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "remove-item-claim-action-validation",
+  async function ({
+    order,
+    orderChange,
+    orderClaim,
+    input,
+  }: {
+    order: OrderDTO
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+    input: OrderWorkflow.DeleteOrderClaimItemActionWorkflowInput
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    const associatedAction = (orderChange.actions ?? []).find(
+      (a) => a.id === input.action_id
+    ) as OrderChangeActionDTO
+
+    if (!associatedAction) {
+      throw new Error(
+        `No item claim found for claim ${input.claim_id} in order change ${orderChange.id}`
+      )
+    } else if (associatedAction.action !== ChangeActionType.WRITE_OFF_ITEM) {
+      throw new Error(`Action ${associatedAction.id} is not claiming an item`)
+    }
+  }
+)
+
+export const removeItemClaimActionWorkflowId = "remove-item-claim-action"
+export const removeItemClaimActionWorkflow = createWorkflow(
+  removeItemClaimActionWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.DeleteOrderClaimItemActionWorkflowInput>
+  ): WorkflowData<OrderDTO> {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "canceled_at", "items.*"],
+      variables: { id: orderClaim.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: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ order, input, orderClaim, orderChange })
+
+    deleteOrderChangeActionsStep({ ids: [input.action_id] })
+
+    return previewOrderChangeStep(order.id)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/remove-claim-shipping-method.ts

@@ -0,0 +1,105 @@
+import {
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderWorkflow,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  parallelize,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import { deleteOrderShippingMethods } from "../../steps"
+import { deleteOrderChangeActionsStep } from "../../steps/delete-order-change-actions"
+import { previewOrderChangeStep } from "../../steps/preview-order-change"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "validate-remove-claim-shipping-method",
+  async function ({
+    orderChange,
+    orderClaim,
+    input,
+  }: {
+    input: { claim_id: string; action_id: string }
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    const associatedAction = (orderChange.actions ?? []).find(
+      (a) => a.id === input.action_id
+    ) as OrderChangeActionDTO
+
+    if (!associatedAction) {
+      throw new Error(
+        `No shipping method found for claim ${input.claim_id} in order change ${orderChange.id}`
+      )
+    } else if (associatedAction.action !== ChangeActionType.SHIPPING_ADD) {
+      throw new Error(
+        `Action ${associatedAction.id} is not adding a shipping method`
+      )
+    }
+  }
+)
+
+export const removeClaimShippingMethodWorkflowId =
+  "remove-claim-shipping-method"
+export const removeClaimShippingMethodWorkflow = createWorkflow(
+  removeClaimShippingMethodWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.DeleteClaimShippingMethodWorkflowInput>
+  ): WorkflowData {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const orderChange: OrderChangeDTO = useRemoteQueryStep({
+      entry_point: "order_change",
+      fields: ["id", "status", "version", "actions.*"],
+      variables: {
+        filters: {
+          order_id: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ orderClaim, orderChange, input })
+
+    const dataToRemove = transform(
+      { orderChange, input },
+      ({ orderChange, input }) => {
+        const associatedAction = (orderChange.actions ?? []).find(
+          (a) => a.id === input.action_id
+        ) as OrderChangeActionDTO
+
+        return {
+          actionId: associatedAction.id,
+          shippingMethodId: associatedAction.reference_id,
+        }
+      }
+    )
+
+    parallelize(
+      deleteOrderChangeActionsStep({ ids: [dataToRemove.actionId] }),
+      deleteOrderShippingMethods({ ids: [dataToRemove.shippingMethodId] })
+    )
+
+    return previewOrderChangeStep(orderClaim.order_id)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/update-claim-add-item.ts

@@ -0,0 +1,118 @@
+import {
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+  OrderWorkflow,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import {
+  previewOrderChangeStep,
+  updateOrderChangeActionsStep,
+} from "../../steps"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "update-claim-add-item-validation",
+  async function (
+    {
+      order,
+      orderChange,
+      orderClaim,
+      input,
+    }: {
+      order: OrderDTO
+      orderClaim: OrderClaimDTO
+      orderChange: OrderChangeDTO
+      input: OrderWorkflow.UpdateClaimAddNewItemWorkflowInput
+    },
+    context
+  ) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    const associatedAction = (orderChange.actions ?? []).find(
+      (a) => a.id === input.action_id
+    ) as OrderChangeActionDTO
+
+    if (!associatedAction) {
+      throw new Error(
+        `No request to add item for claim ${input.claim_id} in order change ${orderChange.id}`
+      )
+    } else if (associatedAction.action !== ChangeActionType.ITEM_ADD) {
+      throw new Error(`Action ${associatedAction.id} is not adding an item`)
+    }
+  }
+)
+
+export const updateClaimAddItemWorkflowId = "update-claim-add-item"
+export const updateClaimAddItemWorkflow = createWorkflow(
+  updateClaimAddItemWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.UpdateClaimAddNewItemWorkflowInput>
+  ): WorkflowData<OrderDTO> {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "canceled_at", "items.*"],
+      variables: { id: orderClaim.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: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ order, input, orderClaim, orderChange })
+
+    const updateData = transform(
+      { orderChange, input },
+      ({ input, orderChange }) => {
+        const originalAction = (orderChange.actions ?? []).find(
+          (a) => a.id === input.action_id
+        ) as OrderChangeActionDTO
+
+        const data = input.data
+        return {
+          id: input.action_id,
+          details: {
+            quantity: data.quantity ?? originalAction.details?.quantity,
+          },
+          internal_note: data.internal_note,
+        }
+      }
+    )
+
+    updateOrderChangeActionsStep([updateData])
+
+    return previewOrderChangeStep(order.id)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/update-claim-item.ts

@@ -0,0 +1,118 @@
+import {
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+  OrderWorkflow,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import {
+  previewOrderChangeStep,
+  updateOrderChangeActionsStep,
+} from "../../steps"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "update-claim-item-validation",
+  async function (
+    {
+      order,
+      orderChange,
+      orderClaim,
+      input,
+    }: {
+      order: OrderDTO
+      orderClaim: OrderClaimDTO
+      orderChange: OrderChangeDTO
+      input: OrderWorkflow.UpdateClaimItemWorkflowInput
+    },
+    context
+  ) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    const associatedAction = (orderChange.actions ?? []).find(
+      (a) => a.id === input.action_id
+    ) as OrderChangeActionDTO
+
+    if (!associatedAction) {
+      throw new Error(
+        `No request claim found for claim ${input.claim_id} in order change ${orderChange.id}`
+      )
+    } else if (associatedAction.action !== ChangeActionType.WRITE_OFF_ITEM) {
+      throw new Error(`Action ${associatedAction.id} is not claiming the item`)
+    }
+  }
+)
+
+export const updateClaimItemWorkflowId = "update-claim-item"
+export const updateClaimItemWorkflow = createWorkflow(
+  updateClaimItemWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.UpdateClaimItemWorkflowInput>
+  ): WorkflowData<OrderDTO> {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "canceled_at", "items.*"],
+      variables: { id: orderClaim.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: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ order, input, orderClaim, orderChange })
+
+    const updateData = transform(
+      { orderChange, input },
+      ({ input, orderChange }) => {
+        const originalAction = (orderChange.actions ?? []).find(
+          (a) => a.id === input.action_id
+        ) as OrderChangeActionDTO
+
+        const data = input.data
+        return {
+          id: input.action_id,
+          details: {
+            quantity: data.quantity ?? originalAction.details?.quantity,
+          },
+          internal_note: data.internal_note,
+        }
+      }
+    )
+
+    updateOrderChangeActionsStep([updateData])
+
+    return previewOrderChangeStep(order.id)
+  }
+)

packages/core/core-flows/src/order/workflows/claim/update-claim-shipping-method.ts

@@ -0,0 +1,120 @@
+import {
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderWorkflow,
+} from "@medusajs/types"
+import { ChangeActionType, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  parallelize,
+  transform,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../../common"
+import {
+  updateOrderChangeActionsStep,
+  updateOrderShippingMethodsStep,
+} from "../../steps"
+import { previewOrderChangeStep } from "../../steps/preview-order-change"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+const validationStep = createStep(
+  "validate-update-claim-shipping-method",
+  async function ({
+    orderChange,
+    orderClaim,
+    input,
+  }: {
+    input: { claim_id: string; action_id: string }
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    const associatedAction = (orderChange.actions ?? []).find(
+      (a) => a.id === input.action_id
+    ) as OrderChangeActionDTO
+
+    if (!associatedAction) {
+      throw new Error(
+        `No shipping method found for claim ${input.claim_id} in order change ${orderChange.id}`
+      )
+    } else if (associatedAction.action !== ChangeActionType.SHIPPING_ADD) {
+      throw new Error(
+        `Action ${associatedAction.id} is not adding a shipping method`
+      )
+    }
+  }
+)
+
+export const updateClaimShippingMethodWorkflowId =
+  "update-claim-shipping-method"
+export const updateClaimShippingMethodWorkflow = createWorkflow(
+  updateClaimShippingMethodWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.UpdateClaimShippingMethodWorkflowInput>
+  ): WorkflowData {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "claim",
+      fields: ["id", "status", "order_id", "canceled_at"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    })
+
+    const orderChange: OrderChangeDTO = useRemoteQueryStep({
+      entry_point: "order_change",
+      fields: ["id", "status", "version", "actions.*"],
+      variables: {
+        filters: {
+          order_id: orderClaim.order_id,
+          claim_id: orderClaim.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ orderClaim, orderChange, input })
+
+    const updateData = transform(
+      { orderChange, input },
+      ({ input, orderChange }) => {
+        const originalAction = (orderChange.actions ?? []).find(
+          (a) => a.id === input.action_id
+        ) as OrderChangeActionDTO
+
+        const data = input.data
+
+        const action = {
+          id: originalAction.id,
+          internal_note: data.internal_note,
+        }
+
+        const shippingMethod = {
+          id: originalAction.reference_id,
+          amount: data.custom_price,
+          metadata: data.metadata,
+        }
+
+        return {
+          action,
+          shippingMethod,
+        }
+      }
+    )
+
+    parallelize(
+      updateOrderChangeActionsStep([updateData.action]),
+      updateOrderShippingMethodsStep([updateData.shippingMethod!])
+    )
+
+    return previewOrderChangeStep(orderClaim.order_id)
+  }
+)

packages/core/core-flows/src/order/workflows/index.ts

@@ -4,7 +4,16 @@ export * from "./cancel-order"
 export * from "./cancel-order-change"
 export * from "./cancel-order-fulfillment"
 export * from "./claim/begin-order-claim"
+export * from "./claim/cancel-begin-order-claim"
+export * from "./claim/claim-add-new-item"
+export * from "./claim/claim-item"
 export * from "./claim/claim-request-item-return"
+export * from "./claim/create-claim-shipping-method"
+export * from "./claim/remove-claim-item-action"
+export * from "./claim/remove-claim-shipping-method"
+export * from "./claim/update-claim-add-item"
+export * from "./claim/update-claim-item"
+export * from "./claim/update-claim-shipping-method"
 export * from "./complete-orders"
 export * from "./create-fulfillment"
 export * from "./create-order-change"

packages/core/core-flows/src/order/workflows/return/confirm-receive-return-request.ts

@@ -3,12 +3,14 @@ import {
   OrderChangeActionDTO,
   OrderChangeDTO,
   OrderDTO,
+  OrderReturnItemDTO,
   ReturnDTO,
 } from "@medusajs/types"
 import {
   ChangeActionType,
   MathBN,
   OrderChangeStatus,
+  ReturnStatus,
   deepFlatMap,
 } from "@medusajs/utils"
 import {
@@ -20,7 +22,11 @@ import {
 } from "@medusajs/workflows-sdk"
 import { useRemoteQueryStep } from "../../../common"
 import { adjustInventoryLevelsStep } from "../../../inventory/steps"
-import { previewOrderChangeStep, updateReturnItemsStep } from "../../steps"
+import {
+  previewOrderChangeStep,
+  updateReturnItemsStep,
+  updateReturnsStep,
+} from "../../steps"
 import { confirmOrderChanges } from "../../steps/confirm-order-changes"
 import {
   throwIfIsCancelled,
@@ -173,12 +179,12 @@ export const confirmReturnReceiveWorkflow = createWorkflow(
       list: false,
     }).config({ name: "order-change-query" })
 
-    const { updateReturnItem, returnedQuantityMap } = transform(
+    const { updateReturnItem, returnedQuantityMap, updateReturn } = transform(
       { orderChange, orderReturn },
       (data) => {
         const returnedQuantityMap: Record<string, BigNumberInput> = {}
 
-        const retItems = data.orderReturn.items ?? []
+        const retItems: OrderReturnItemDTO[] = data.orderReturn.items ?? []
         const received: OrderChangeActionDTO[] = []
 
         data.orderChange.actions.forEach((act) => {
@@ -232,9 +238,26 @@ export const confirmReturnReceiveWorkflow = createWorkflow(
           }
         })
 
+        const hasReceivedAllItems = retItems.every((item) => {
+          const received = itemUpdates[item.item_id]
+            ? itemUpdates[item.item_id].received_quantity
+            : item.received_quantity
+
+          return MathBN.eq(received, item.quantity)
+        })
+        const updateReturnData = hasReceivedAllItems
+          ? { status: ReturnStatus.RECEIVED, received_at: new Date() }
+          : { status: ReturnStatus.PARTIALLY_RECEIVED }
+
+        const updateReturn = {
+          id: data.orderReturn.id,
+          ...updateReturnData,
+        }
+
         return {
           updateReturnItem: Object.values(itemUpdates) as any,
           returnedQuantityMap,
+          updateReturn,
         }
       }
     )
@@ -247,6 +270,7 @@ export const confirmReturnReceiveWorkflow = createWorkflow(
     validationStep({ order, orderReturn, orderChange })
 
     parallelize(
+      updateReturnsStep([updateReturn]),
       updateReturnItemsStep(updateReturnItem),
       confirmOrderChanges({ changes: [orderChange], orderId: order.id }),
       adjustInventoryLevelsStep(inventoryAdjustment)

packages/core/core-flows/src/order/workflows/return/create-return-shipping-method.ts

@@ -43,6 +43,8 @@ export const createReturnShippingMethodWorkflow = createWorkflow(
   createReturnShippingMethodWorkflowId,
   function (input: {
     return_id: string
+    claim_id?: string
+    exchange_id?: string
     shipping_option_id: string
     custom_price?: BigNumberInput
   }): WorkflowData<OrderDTO> {
@@ -99,6 +101,7 @@ export const createReturnShippingMethodWorkflow = createWorkflow(
         shippingOptions,
         customPrice: input.custom_price,
         orderChange,
+        input,
       },
       (data) => {
         const option = data.shippingOptions[0]
@@ -114,6 +117,8 @@ export const createReturnShippingMethodWorkflow = createWorkflow(
           version: orderChange.version,
           order_id: data.orderReturn.order_id,
           return_id: data.orderReturn.id,
+          claim_id: data.input.claim_id,
+          exchange_id: data.input.exchange_id,
         }
       }
     )
@@ -130,6 +135,7 @@ export const createReturnShippingMethodWorkflow = createWorkflow(
         createdMethods,
         customPrice: input.custom_price,
         orderChange,
+        input,
       },
       ({
         shippingOptions,
@@ -138,6 +144,7 @@ export const createReturnShippingMethodWorkflow = createWorkflow(
         createdMethods,
         customPrice,
         orderChange,
+        input,
       }) => {
         const shippingOption = shippingOptions[0]
         const createdMethod = createdMethods[0]
@@ -152,6 +159,8 @@ export const createReturnShippingMethodWorkflow = createWorkflow(
           amount: methodPrice,
           order_id: order.id,
           return_id: orderReturn.id,
+          claim_id: input.claim_id,
+          exchange_id: input.exchange_id,
         }
       }
     )

packages/core/core-flows/src/order/workflows/return/update-request-item-return.ts

@@ -119,7 +119,6 @@ export const updateRequestItemReturnWorkflow = createWorkflow(
           details: {
             quantity: data.quantity ?? originalAction.details?.quantity,
             reason_id: data.reason_id ?? originalAction.details?.reason_id,
-            metadata: data.metadata ?? originalAction.details?.metadata,
           },
           internal_note: data.internal_note,
         }