feat(core-flows): request return on order exchanges and claims (#8107)

FIXES: CC-92, CC-87

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

@@ -16,8 +16,10 @@ export * from "./decline-order-change"
 export * from "./delete-order-change"
 export * from "./delete-order-change-actions"
 export * from "./get-item-tax-lines"
+export * from "./preview-order-change"
 export * from "./register-fulfillment"
 export * from "./register-shipment"
 export * from "./set-tax-lines-for-items"
 export * from "./update-order-change-actions"
+export * from "./update-order-exchanges"
 export * from "./update-tax-lines"

packages/core/core-flows/src/order/steps/preview-order-change.ts

@@ -0,0 +1,17 @@
+import { IOrderModuleService } from "@medusajs/types"
+import { ModuleRegistrationName } from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+export const previewOrderChangeStepId = "preview-order-change"
+export const previewOrderChangeStep = createStep(
+  previewOrderChangeStepId,
+  async (orderId: string, { container }) => {
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const preview = await service.previewOrderChange(orderId)
+
+    return new StepResponse(preview)
+  }
+)

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

@@ -0,0 +1,55 @@
+import { IOrderModuleService, UpdateOrderClaimDTO } from "@medusajs/types"
+import {
+  ModuleRegistrationName,
+  getSelectsAndRelationsFromObjectArray,
+} from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+export const updateOrderClaimsStepId = "update-order-claim"
+export const updateOrderClaimsStep = createStep(
+  updateOrderClaimsStepId,
+  async (data: UpdateOrderClaimDTO[], { container }) => {
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const { selects, relations } = getSelectsAndRelationsFromObjectArray(data, {
+      objectFields: ["metadata"],
+    })
+    const dataBeforeUpdate = await service.listOrderClaims(
+      { id: data.map((d) => d.id) },
+      { relations, select: selects }
+    )
+
+    const updated = await service.updateOrderClaims(
+      data.map((dt) => {
+        const { id, ...rest } = dt
+        return {
+          selector: { id },
+          data: rest,
+        }
+      })
+    )
+
+    return new StepResponse(updated, dataBeforeUpdate)
+  },
+  async (dataBeforeUpdate, { container }) => {
+    if (!dataBeforeUpdate?.length) {
+      return
+    }
+
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    await service.updateOrderClaims(
+      dataBeforeUpdate.map((dt) => {
+        const { id, ...rest } = dt
+        return {
+          selector: { id },
+          data: rest,
+        }
+      })
+    )
+  }
+)

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

@@ -0,0 +1,55 @@
+import { IOrderModuleService, UpdateOrderExchangeDTO } from "@medusajs/types"
+import {
+  ModuleRegistrationName,
+  getSelectsAndRelationsFromObjectArray,
+} from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+export const updateOrderExchangesStepId = "update-order-exchange"
+export const updateOrderExchangesStep = createStep(
+  updateOrderExchangesStepId,
+  async (data: UpdateOrderExchangeDTO[], { container }) => {
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const { selects, relations } = getSelectsAndRelationsFromObjectArray(data, {
+      objectFields: ["metadata"],
+    })
+    const dataBeforeUpdate = await service.listOrderExchanges(
+      { id: data.map((d) => d.id) },
+      { relations, select: selects }
+    )
+
+    const updated = await service.updateOrderExchanges(
+      data.map((dt) => {
+        const { id, ...rest } = dt
+        return {
+          selector: { id },
+          data: rest,
+        }
+      })
+    )
+
+    return new StepResponse(updated, dataBeforeUpdate)
+  },
+  async (dataBeforeUpdate, { container }) => {
+    if (!dataBeforeUpdate?.length) {
+      return
+    }
+
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    await service.updateOrderExchanges(
+      dataBeforeUpdate.map((dt) => {
+        const { id, ...rest } = dt
+        return {
+          selector: { id },
+          data: rest,
+        }
+      })
+    )
+  }
+)

packages/core/core-flows/src/order/utils/order-validation.ts

@@ -41,15 +41,14 @@ export function throwIfItemsDoesNotExistsInOrder({
   }
 }
 
-export function throwIfReturnIsCancelled({
-  orderReturn,
-}: {
-  orderReturn: ReturnDTO
-}) {
-  if (orderReturn.canceled_at) {
+export function throwIfIsCancelled(
+  obj: unknown & { id: string; canceled_at?: any },
+  type: string
+) {
+  if (obj.canceled_at) {
     throw new MedusaError(
       MedusaError.Types.INVALID_DATA,
-      `return with id ${orderReturn.id} has been canceled.`
+      `${type} with id ${obj.id} has been canceled.`
     )
   }
 }

packages/core/core-flows/src/order/workflows/cancel-return.ts

@@ -12,7 +12,7 @@ import {
 } from "@medusajs/workflows-sdk"
 import { useRemoteQueryStep } from "../../common"
 import { cancelOrderReturnStep } from "../steps"
-import { throwIfReturnIsCancelled } from "../utils/order-validation"
+import { throwIfIsCancelled } from "../utils/order-validation"
 
 const validateOrder = createStep(
   "validate-return",
@@ -27,7 +27,7 @@ const validateOrder = createStep(
       fulfillments: FulfillmentDTO[]
     }
 
-    throwIfReturnIsCancelled({ orderReturn })
+    throwIfIsCancelled(orderReturn, "Return")
 
     const throwErrorIf = (
       arr: unknown[],

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

@@ -0,0 +1,163 @@
+import {
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+  OrderWorkflow,
+  ReturnDTO,
+} from "@medusajs/types"
+import { ChangeActionType } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+  when,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../common"
+import { createOrderChangeActionsStep } from "../steps/create-order-change-actions"
+import { createReturnsStep } from "../steps/create-returns"
+import { previewOrderChangeStep } from "../steps/preview-order-change"
+import { updateOrderClaimsStep } from "../steps/update-order-claims"
+import {
+  throwIfIsCancelled,
+  throwIfItemsDoesNotExistsInOrder,
+  throwIfOrderChangeIsNotActive,
+  throwIfOrderIsCancelled,
+} from "../utils/order-validation"
+
+const validationStep = createStep(
+  "claim-request-item-return-validation",
+  async function ({
+    order,
+    orderChange,
+    orderReturn,
+    orderClaim,
+    items,
+  }: {
+    order: OrderDTO
+    orderReturn: ReturnDTO
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+    items: OrderWorkflow.OrderClaimRequestItemReturnWorkflowInput["items"]
+  }) {
+    throwIfOrderIsCancelled({ order })
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfIsCancelled(orderReturn, "Return")
+    throwIfOrderChangeIsNotActive({ orderChange })
+    throwIfItemsDoesNotExistsInOrder({ order, inputItems: items })
+  }
+)
+
+export const orderClaimRequestItemReturnWorkflowId = "claim-request-item-return"
+export const orderClaimRequestItemReturnWorkflow = createWorkflow(
+  orderClaimRequestItemReturnWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.OrderClaimRequestItemReturnWorkflowInput>
+  ): WorkflowData<OrderDTO> {
+    const orderClaim = useRemoteQueryStep({
+      entry_point: "order_claim",
+      fields: ["id", "order_id", "return_id"],
+      variables: { id: input.claim_id },
+      list: false,
+      throw_if_key_not_found: true,
+    }).config({ name: "claim-query" })
+
+    const existingOrderReturn = when({ orderClaim }, ({ orderClaim }) => {
+      return orderClaim.return_id
+    }).then(() => {
+      return useRemoteQueryStep({
+        entry_point: "return",
+        fields: ["id", "status", "order_id"],
+        variables: { id: orderClaim.return_id },
+        list: false,
+        throw_if_key_not_found: true,
+      }).config({ name: "return-query" }) as ReturnDTO
+    })
+
+    const createdReturn = when({ orderClaim }, ({ orderClaim }) => {
+      return !orderClaim.return_id
+    }).then(() => {
+      return createReturnsStep([
+        {
+          order_id: orderClaim.order_id,
+          claim_id: orderClaim.id,
+        },
+      ])
+    })
+
+    const orderReturn: ReturnDTO = transform(
+      { createdReturn, existingOrderReturn, orderClaim },
+      ({ createdReturn, existingOrderReturn, orderClaim }) => {
+        return existingOrderReturn ?? (createdReturn[0] as ReturnDTO)
+      }
+    )
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "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: { order_id: orderClaim.order_id },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({
+      order,
+      items: input.items,
+      orderClaim,
+      orderReturn,
+      orderChange,
+    })
+
+    when({ orderClaim }, ({ orderClaim }) => {
+      return !orderClaim.return_id
+    }).then(() => {
+      const createdReturnId = transform(
+        { createdReturn },
+        ({ createdReturn }) => {
+          return createdReturn[0]!.id
+        }
+      )
+      updateOrderClaimsStep([
+        {
+          id: orderClaim.id,
+          return_id: createdReturnId,
+        },
+      ])
+    })
+
+    const orderChangeActionInput = transform(
+      { order, orderChange, orderClaim, orderReturn, items: input.items },
+      ({ order, orderChange, orderClaim, orderReturn, items }) => {
+        return items.map((item) => ({
+          order_change_id: orderChange.id,
+          order_id: order.id,
+          claim_id: orderClaim.id,
+          return_id: orderReturn.id,
+          version: orderChange.version,
+          action: ChangeActionType.RETURN_ITEM,
+          internal_note: item.internal_note,
+          reference: "return",
+          reference_id: orderReturn.id,
+          details: {
+            reference_id: item.id,
+            claim_id: orderClaim.id,
+            return_id: orderReturn.id,
+            quantity: item.quantity,
+            metadata: item.metadata,
+          },
+        }))
+      }
+    )
+
+    createOrderChangeActionsStep(orderChangeActionInput)
+
+    return previewOrderChangeStep(orderClaim.order_id)
+  }
+)

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

@@ -0,0 +1,164 @@
+import {
+  OrderChangeDTO,
+  OrderDTO,
+  OrderExchangeDTO,
+  OrderWorkflow,
+  ReturnDTO,
+} from "@medusajs/types"
+import { ChangeActionType } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+  when,
+} from "@medusajs/workflows-sdk"
+import { useRemoteQueryStep } from "../../common"
+import { createOrderChangeActionsStep } from "../steps/create-order-change-actions"
+import { createReturnsStep } from "../steps/create-returns"
+import { previewOrderChangeStep } from "../steps/preview-order-change"
+import { updateOrderExchangesStep } from "../steps/update-order-exchanges"
+import {
+  throwIfIsCancelled,
+  throwIfItemsDoesNotExistsInOrder,
+  throwIfOrderChangeIsNotActive,
+  throwIfOrderIsCancelled,
+} from "../utils/order-validation"
+
+const validationStep = createStep(
+  "exchange-request-item-return-validation",
+  async function ({
+    order,
+    orderChange,
+    orderReturn,
+    orderExchange,
+    items,
+  }: {
+    order: OrderDTO
+    orderReturn: ReturnDTO
+    orderExchange: OrderExchangeDTO
+    orderChange: OrderChangeDTO
+    items: OrderWorkflow.OrderExchangeRequestItemReturnWorkflowInput["items"]
+  }) {
+    throwIfOrderIsCancelled({ order })
+    throwIfIsCancelled(orderExchange, "Exchange")
+    throwIfIsCancelled(orderReturn, "Return")
+    throwIfOrderChangeIsNotActive({ orderChange })
+    throwIfItemsDoesNotExistsInOrder({ order, inputItems: items })
+  }
+)
+
+export const orderExchangeRequestItemReturnWorkflowId =
+  "exchange-request-item-return"
+export const orderExchangeRequestItemReturnWorkflow = createWorkflow(
+  orderExchangeRequestItemReturnWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.OrderExchangeRequestItemReturnWorkflowInput>
+  ): WorkflowData<OrderDTO> {
+    const orderExchange = useRemoteQueryStep({
+      entry_point: "order_exchange",
+      fields: ["id", "order_id", "return_id"],
+      variables: { id: input.exchange_id },
+      list: false,
+      throw_if_key_not_found: true,
+    }).config({ name: "exchange-query" })
+
+    const existingOrderReturn = when({ orderExchange }, ({ orderExchange }) => {
+      return orderExchange.return_id
+    }).then(() => {
+      return useRemoteQueryStep({
+        entry_point: "return",
+        fields: ["id", "status", "order_id"],
+        variables: { id: orderExchange.return_id },
+        list: false,
+        throw_if_key_not_found: true,
+      }).config({ name: "return-query" }) as ReturnDTO
+    })
+
+    const createdReturn = when({ orderExchange }, ({ orderExchange }) => {
+      return !orderExchange.return_id
+    }).then(() => {
+      return createReturnsStep([
+        {
+          order_id: orderExchange.order_id,
+          exchange_id: orderExchange.id,
+        },
+      ])
+    })
+
+    const orderReturn: ReturnDTO = transform(
+      { createdReturn, existingOrderReturn, orderExchange },
+      ({ createdReturn, existingOrderReturn, orderExchange }) => {
+        return existingOrderReturn ?? (createdReturn[0] as ReturnDTO)
+      }
+    )
+
+    const order: OrderDTO = useRemoteQueryStep({
+      entry_point: "orders",
+      fields: ["id", "status", "items.*"],
+      variables: { id: orderExchange.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: { order_id: orderExchange.order_id },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({
+      order,
+      items: input.items,
+      orderExchange,
+      orderReturn,
+      orderChange,
+    })
+
+    when({ orderExchange }, ({ orderExchange }) => {
+      return !orderExchange.return_id
+    }).then(() => {
+      const createdReturnId = transform(
+        { createdReturn },
+        ({ createdReturn }) => {
+          return createdReturn[0]!.id
+        }
+      )
+      updateOrderExchangesStep([
+        {
+          id: orderExchange.id,
+          return_id: createdReturnId,
+        },
+      ])
+    })
+
+    const orderChangeActionInput = transform(
+      { order, orderChange, orderExchange, orderReturn, items: input.items },
+      ({ order, orderChange, orderExchange, orderReturn, items }) => {
+        return items.map((item) => ({
+          order_change_id: orderChange.id,
+          order_id: order.id,
+          exchange_id: orderExchange.id,
+          return_id: orderReturn.id,
+          version: orderChange.version,
+          action: ChangeActionType.RETURN_ITEM,
+          internal_note: item.internal_note,
+          reference: "return",
+          reference_id: orderReturn.id,
+          details: {
+            reference_id: item.id,
+            exchange_id: orderExchange.id,
+            return_id: orderReturn.id,
+            quantity: item.quantity,
+            metadata: item.metadata,
+          },
+        }))
+      }
+    )
+
+    createOrderChangeActionsStep(orderChangeActionInput)
+
+    return previewOrderChangeStep(orderExchange.order_id)
+  }
+)

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

@@ -6,6 +6,7 @@ export * from "./cancel-order"
 export * from "./cancel-order-change"
 export * from "./cancel-order-fulfillment"
 export * from "./cancel-return"
+export * from "./claim-request-item-return"
 export * from "./complete-orders"
 export * from "./create-complete-return"
 export * from "./create-fulfillment"
@@ -16,6 +17,7 @@ export * from "./create-shipment"
 export * from "./decline-order-change"
 export * from "./delete-order-change"
 export * from "./delete-order-change-actions"
+export * from "./exchange-request-item-return"
 export * from "./get-order-detail"
 export * from "./get-orders-list"
 export * from "./receive-return"

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

@@ -9,8 +9,8 @@ import { useRemoteQueryStep } from "../../common"
 import { ReturnDTO } from "@medusajs/types"
 import { receiveReturnStep } from "../steps/receive-return"
 import {
+  throwIfIsCancelled,
   throwIfItemsDoesNotExistsInReturn,
-  throwIfReturnIsCancelled,
 } from "../utils/order-validation"
 
 const validationStep = createStep(
@@ -25,7 +25,7 @@ const validationStep = createStep(
     },
     context
   ) {
-    throwIfReturnIsCancelled({ orderReturn })
+    throwIfIsCancelled(orderReturn, "Return")
     throwIfItemsDoesNotExistsInReturn({ orderReturn, inputItems: input.items })
   }
 )

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

@@ -15,10 +15,10 @@ import {
 import { useRemoteQueryStep } from "../../common"
 import { createOrderChangeActionsStep } from "../steps/create-order-change-actions"
 import {
+  throwIfIsCancelled,
   throwIfItemsDoesNotExistsInOrder,
   throwIfOrderChangeIsNotActive,
   throwIfOrderIsCancelled,
-  throwIfReturnIsCancelled,
 } from "../utils/order-validation"
 
 const validationStep = createStep(
@@ -35,7 +35,7 @@ const validationStep = createStep(
     items: OrderWorkflow.RequestItemReturnWorkflowInput["items"]
   }) {
     throwIfOrderIsCancelled({ order })
-    throwIfReturnIsCancelled({ orderReturn })
+    throwIfIsCancelled(orderReturn, "Return")
     throwIfOrderChangeIsNotActive({ orderChange })
     throwIfItemsDoesNotExistsInOrder({ order, inputItems: items })
   }
@@ -49,7 +49,7 @@ export const requestItemReturnWorkflow = createWorkflow(
   ): WorkflowData<OrderChangeActionDTO[]> {
     const orderReturn: ReturnDTO = useRemoteQueryStep({
       entry_point: "return",
-      fields: ["id", "status", "refund_amount", "order_id", "items.*"],
+      fields: ["id", "status", "order_id"],
       variables: { id: input.return_id },
       list: false,
       throw_if_key_not_found: true,