feat(medusa,core-flows,types,js-sdk): decline / cancel order transfer (#10202)

**What**
- **core-flows**: 
  - cancel transfer
  - decline transfer
- **API**:
  - admin cancel transfer
  - store decline transfer 
  - store cancel transfer
- **js-sdk**:
  - add methods for store endpoints 

---

CLOSES CMRC-726

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

@@ -80,3 +80,5 @@ export * from "./update-order-changes"
 export * from "./update-tax-lines"
 export * from "./transfer/request-order-transfer"
 export * from "./transfer/accept-order-transfer"
+export * from "./transfer/cancel-order-transfer"
+export * from "./transfer/decline-order-transfer"

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

@@ -41,7 +41,9 @@ export const cancelBeginOrderEditWorkflowId = "cancel-begin-order-edit"
  */
 export const cancelBeginOrderEditWorkflow = createWorkflow(
   cancelBeginOrderEditWorkflowId,
-  function (input: CancelBeginOrderEditWorkflowInput): WorkflowData<void> {
+  function (
+    input: WorkflowData<CancelBeginOrderEditWorkflowInput>
+  ): WorkflowData<void> {
     const order: OrderDTO = useRemoteQueryStep({
       entry_point: "orders",
       fields: ["id", "version", "canceled_at"],

packages/core/core-flows/src/order/workflows/transfer/accept-order-transfer.ts

@@ -8,17 +8,18 @@ import {
   WorkflowResponse,
   createStep,
   createWorkflow,
+  transform,
 } from "@medusajs/framework/workflows-sdk"
 import { OrderPreviewDTO } from "@medusajs/types"
-
-import { useRemoteQueryStep } from "../../../common"
-import { throwIfOrderIsCancelled } from "../../utils/order-validation"
-import { previewOrderChangeStep } from "../../steps"
 import {
   ChangeActionType,
   MedusaError,
   OrderChangeStatus,
 } from "@medusajs/utils"
+
+import { useQueryGraphStep } from "../../../common"
+import { throwIfOrderIsCancelled } from "../../utils/order-validation"
+import { previewOrderChangeStep } from "../../steps"
 import { confirmOrderChanges } from "../../steps/confirm-order-changes"
 
 /**
@@ -62,16 +63,20 @@ export const acceptOrderTransferWorkflow = createWorkflow(
   function (
     input: WorkflowData<OrderWorkflow.AcceptOrderTransferWorkflowInput>
   ): WorkflowResponse<OrderPreviewDTO> {
-    const order: OrderDTO = useRemoteQueryStep({
-      entry_point: "orders",
+    const orderQuery = useQueryGraphStep({
+      entity: "order",
       fields: ["id", "email", "status", "customer_id"],
-      variables: { id: input.order_id },
-      list: false,
-      throw_if_key_not_found: true,
-    })
+      filters: { id: input.order_id },
+      options: { throwIfKeyNotFound: true },
+    }).config({ name: "order-query" })
 
-    const orderChange: OrderChangeDTO = useRemoteQueryStep({
-      entry_point: "order_change",
+    const order = transform(
+      { orderQuery },
+      ({ orderQuery }) => orderQuery.data[0]
+    )
+
+    const orderChangeQuery = useQueryGraphStep({
+      entity: "order_change",
       fields: [
         "id",
         "status",
@@ -84,15 +89,18 @@ export const acceptOrderTransferWorkflow = createWorkflow(
         "actions.reference_id",
         "actions.internal_note",
       ],
-      variables: {
-        filters: {
-          order_id: input.order_id,
-          status: [OrderChangeStatus.REQUESTED],
-        },
+      filters: {
+        order_id: input.order_id,
+        status: [OrderChangeStatus.REQUESTED],
       },
-      list: false,
+      options: { throwIfKeyNotFound: true },
     }).config({ name: "order-change-query" })
 
+    const orderChange = transform(
+      { orderChangeQuery },
+      ({ orderChangeQuery }) => orderChangeQuery.data[0]
+    )
+
     acceptOrderTransferValidationStep({
       order,
       orderChange,

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

@@ -0,0 +1,101 @@
+import {
+  OrderChangeDTO,
+  OrderDTO,
+  OrderWorkflow,
+} from "@medusajs/framework/types"
+import {
+  ChangeActionType,
+  MedusaError,
+  OrderChangeStatus,
+} from "@medusajs/framework/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+} from "@medusajs/framework/workflows-sdk"
+import { useQueryGraphStep } from "../../../common"
+import { deleteOrderChangesStep } from "../../steps"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+/**
+ * This step validates that a requested order transfer can be canceled.
+ */
+export const cancelTransferOrderRequestValidationStep = createStep(
+  "validate-cancel-transfer-order-request",
+  async function ({
+    order,
+    orderChange,
+    input,
+  }: {
+    order: OrderDTO
+    orderChange: OrderChangeDTO
+    input: OrderWorkflow.CancelTransferOrderRequestWorkflowInput
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    if (input.actor_type === "user") {
+      return
+    }
+
+    const action = orderChange.actions?.find(
+      (a) => a.action === ChangeActionType.TRANSFER_CUSTOMER
+    )
+
+    if (action?.reference_id !== input.logged_in_user_id) {
+      throw new MedusaError(
+        MedusaError.Types.NOT_ALLOWED,
+        "This customer is not allowed to cancel the transfer."
+      )
+    }
+  }
+)
+
+export const cancelTransferOrderRequestWorkflowId =
+  "cancel-transfer-order-request"
+/**
+ * This workflow cancels a requested order transfer.
+ *
+ * Customer that requested the transfer or a store admin are allowed to cancel the order transfer request.
+ */
+export const cancelOrderTransferRequestWorkflow = createWorkflow(
+  cancelTransferOrderRequestWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.CancelTransferOrderRequestWorkflowInput>
+  ): WorkflowData<void> {
+    const orderQuery = useQueryGraphStep({
+      entity: "order",
+      fields: ["id", "version", "canceled_at"],
+      filters: { id: input.order_id },
+      options: { throwIfKeyNotFound: true },
+    }).config({ name: "order-query" })
+
+    const order = transform(
+      { orderQuery },
+      ({ orderQuery }) => orderQuery.data[0]
+    )
+
+    const orderChangeQuery = useQueryGraphStep({
+      entity: "order_change",
+      fields: ["id", "status", "version", "actions.*"],
+      filters: {
+        order_id: input.order_id,
+        status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+      },
+      options: { throwIfKeyNotFound: true },
+    }).config({ name: "order-change-query" })
+
+    const orderChange = transform(
+      { orderChangeQuery },
+      ({ orderChangeQuery }) => orderChangeQuery.data[0]
+    )
+
+    cancelTransferOrderRequestValidationStep({ order, orderChange, input })
+
+    deleteOrderChangesStep({ ids: [orderChange.id] })
+  }
+)

packages/core/core-flows/src/order/workflows/transfer/decline-order-transfer.ts

@@ -0,0 +1,95 @@
+import {
+  OrderChangeDTO,
+  OrderDTO,
+  OrderWorkflow,
+} from "@medusajs/framework/types"
+import {
+  ChangeActionType,
+  MedusaError,
+  OrderChangeStatus,
+} from "@medusajs/framework/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  transform,
+} from "@medusajs/framework/workflows-sdk"
+
+import { useQueryGraphStep } from "../../../common"
+import { declineOrderChangeStep } from "../../steps"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+/**
+ * This step validates that a requested order transfer can be declineed.
+ */
+export const declineTransferOrderRequestValidationStep = createStep(
+  "validate-decline-transfer-order-request",
+  async function ({
+    order,
+    orderChange,
+    input,
+  }: {
+    order: OrderDTO
+    orderChange: OrderChangeDTO
+    input: OrderWorkflow.DeclineTransferOrderRequestWorkflowInput
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfOrderChangeIsNotActive({ orderChange })
+
+    const token = orderChange.actions?.find(
+      (a) => a.action === ChangeActionType.TRANSFER_CUSTOMER
+    )?.details!.token
+
+    if (!input.token?.length || token !== input.token) {
+      throw new MedusaError(MedusaError.Types.NOT_ALLOWED, "Invalid token.")
+    }
+  }
+)
+
+export const declineTransferOrderRequestWorkflowId =
+  "decline-transfer-order-request"
+/**
+ * This workflow declines a requested order transfer.
+ *
+ * Only the original customer (who has the token) is allowed to decline the transfer.
+ */
+export const declineOrderTransferRequestWorkflow = createWorkflow(
+  declineTransferOrderRequestWorkflowId,
+  function (
+    input: WorkflowData<OrderWorkflow.DeclineTransferOrderRequestWorkflowInput>
+  ): WorkflowData<void> {
+    const orderQuery = useQueryGraphStep({
+      entity: "order",
+      fields: ["id", "version", "declineed_at"],
+      filters: { id: input.order_id },
+      options: { throwIfKeyNotFound: true },
+    }).config({ name: "order-query" })
+
+    const order = transform(
+      { orderQuery },
+      ({ orderQuery }) => orderQuery.data[0]
+    )
+
+    const orderChangeQuery = useQueryGraphStep({
+      entity: "order_change",
+      fields: ["id", "status", "version", "actions.*"],
+      filters: {
+        order_id: input.order_id,
+        status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+      },
+      options: { throwIfKeyNotFound: true },
+    }).config({ name: "order-change-query" })
+
+    const orderChange = transform(
+      { orderChangeQuery },
+      ({ orderChangeQuery }) => orderChangeQuery.data[0]
+    )
+
+    declineTransferOrderRequestValidationStep({ order, orderChange, input })
+
+    declineOrderChangeStep({ id: orderChange.id })
+  }
+)

packages/core/core-flows/src/order/workflows/transfer/request-order-transfer.ts

@@ -131,7 +131,7 @@ export const requestOrderTransferWorkflow = createWorkflow(
 
     emitEventStep({
       eventName: OrderWorkflowEvents.TRANSFER_REQUESTED,
-      data: { id: input.order_id },
+      data: { id: input.order_id, order_change_id: change.id },
     })
 
     return new WorkflowResponse(previewOrderChangeStep(input.order_id))