feat(core-flows,medusa,order): remove return shipping

integration-tests/http/__tests__/returns/returns.spec.ts

@@ -268,6 +268,26 @@ medusaIntegrationTestRunner({
           })
         )
 
+        expect(result.data.order.shipping_methods).toHaveLength(2)
+
+        // remove shipping method
+        const action_id = result.data.order.shipping_methods[1].actions[0].id
+        result = await api.delete(
+          `/admin/returns/${returnId}/shipping-method/${action_id}`,
+          adminHeaders
+        )
+
+        expect(result.data.order_preview.shipping_methods).toHaveLength(1)
+
+        // recreate shipping
+        result = await api.post(
+          `/admin/returns/${returnId}/shipping-method`,
+          {
+            shipping_option_id: returnShippingOption.id,
+          },
+          adminHeaders
+        )
+
         result = await api.post(
           `/admin/returns/${returnId}/request`,
           {},

integration-tests/modules/__tests__/order/workflows/order-change.spec.ts

@@ -184,7 +184,7 @@ medusaIntegrationTestRunner({
 
         it("should successfully delete an order change", async () => {
           await deleteOrderChangeWorkflow(container).run({
-            input: { id: orderChange.id },
+            input: { ids: orderChange.id },
           })
 
           const orderChange2 = await service.retrieveOrderChange(

packages/core/core-flows/src/order/steps/create-line-items.ts

@@ -6,7 +6,7 @@ interface StepInput {
   items: CreateOrderLineItemDTO[]
 }
 
-export const createOrderLineItemsStepId = "create-line-items-step"
+export const createOrderLineItemsStepId = "create-order-line-items-step"
 export const createOrderLineItemsStep = createStep(
   createOrderLineItemsStepId,
   async (input: StepInput, { container }) => {

packages/core/core-flows/src/order/steps/delete-line-items.ts

@@ -0,0 +1,31 @@
+import { IOrderModuleService } from "@medusajs/types"
+import { ModuleRegistrationName } from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+interface StepInput {
+  ids: string[]
+}
+
+export const deleteOrderLineItems = createStep(
+  "delete-order-line-items",
+  async (input: StepInput, { container }) => {
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const deleted = await service.softDeleteLineItems(input.ids)
+
+    return new StepResponse(deleted, input.ids)
+  },
+  async (ids, { container }) => {
+    if (!ids) {
+      return
+    }
+
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    await service.restoreLineItems(ids)
+  }
+)

packages/core/core-flows/src/order/steps/delete-order-change.ts → packages/core/core-flows/src/order/steps/delete-order-changes.ts

@@ -2,27 +2,27 @@ import { IOrderModuleService } from "@medusajs/types"
 import { ModuleRegistrationName } from "@medusajs/utils"
 import { createStep, StepResponse } from "@medusajs/workflows-sdk"
 
-export const deleteOrderChangeStepId = "delete-order-change"
-export const deleteOrderChangeStep = createStep(
-  deleteOrderChangeStepId,
-  async (data: { id: string }, { container }) => {
+export const deleteOrderChangesStepId = "delete-order-change"
+export const deleteOrderChangesStep = createStep(
+  deleteOrderChangesStepId,
+  async (data: { ids: string[] }, { container }) => {
     const service = container.resolve<IOrderModuleService>(
       ModuleRegistrationName.ORDER
     )
 
-    const deleted = await service.softDeleteOrderChanges(data.id)
+    const deleted = await service.softDeleteOrderChanges(data.ids)
 
-    return new StepResponse(deleted, data.id)
+    return new StepResponse(deleted, data.ids)
   },
-  async (id, { container }) => {
-    if (!id) {
+  async (ids, { container }) => {
+    if (!ids) {
       return
     }
 
     const service = container.resolve<IOrderModuleService>(
       ModuleRegistrationName.ORDER
     )
 
-    await service.restoreOrderChanges(id)
+    await service.restoreOrderChanges(ids)
   }
 )

packages/core/core-flows/src/order/steps/delete-order-shipping-methods.ts

@@ -0,0 +1,31 @@
+import { IOrderModuleService } from "@medusajs/types"
+import { ModuleRegistrationName } from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+interface StepInput {
+  ids: string[]
+}
+
+export const deleteOrderShippingMethods = createStep(
+  "delete-order-shipping-methods",
+  async (input: StepInput, { container }) => {
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const deleted = await service.softDeleteShippingMethods(input.ids)
+
+    return new StepResponse(deleted, input.ids)
+  },
+  async (ids, { container }) => {
+    if (!ids) {
+      return
+    }
+
+    const service = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    await service.restoreShippingMethods(ids)
+  }
+)

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

@@ -14,8 +14,10 @@ export * from "./create-order-change-actions"
 export * from "./create-orders"
 export * from "./create-returns"
 export * from "./decline-order-change"
-export * from "./delete-order-change"
+export * from "./delete-line-items"
 export * from "./delete-order-change-actions"
+export * from "./delete-order-changes"
+export * from "./delete-order-shipping-methods"
 export * from "./get-item-tax-lines"
 export * from "./preview-order-change"
 export * from "./register-fulfillment"

packages/core/core-flows/src/order/workflows/delete-order-change.ts

@@ -1,10 +1,10 @@
 import { WorkflowData, createWorkflow } from "@medusajs/workflows-sdk"
-import { deleteOrderChangeStep } from "../steps"
+import { deleteOrderChangesStep } from "../steps"
 
 export const deleteOrderChangeWorkflowId = "delete-order-change"
 export const deleteOrderChangeWorkflow = createWorkflow(
   deleteOrderChangeWorkflowId,
-  (input: WorkflowData<{ id: string }>): WorkflowData<void> => {
-    deleteOrderChangeStep(input)
+  (input: WorkflowData<{ ids: string[] }>): WorkflowData<void> => {
+    deleteOrderChangesStep(input)
   }
 )

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

@@ -26,7 +26,7 @@ export * from "./exchange-request-item-return"
 export * from "./get-order-detail"
 export * from "./get-orders-list"
 export * from "./receive-return"
+export * from "./remove-return-shipping-method"
 export * from "./request-item-return"
 export * from "./update-order-change-actions"
 export * from "./update-tax-lines"
-

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

@@ -0,0 +1,102 @@
+import {
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  ReturnDTO,
+} 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-return-shipping-method",
+  async function ({
+    orderChange,
+    orderReturn,
+    input,
+  }: {
+    input: { return_id: string; action_id: string }
+    orderReturn: ReturnDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(orderReturn, "Return")
+    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 return ${input.return_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 removeReturnShippingMethodWorkflowId =
+  "remove-return-shipping-method"
+export const removeReturnShippingMethodWorkflow = createWorkflow(
+  removeReturnShippingMethodWorkflowId,
+  function (input: { return_id: string; action_id: string }): WorkflowData {
+    const orderReturn: ReturnDTO = useRemoteQueryStep({
+      entry_point: "return",
+      fields: ["id", "status", "order_id"],
+      variables: { id: input.return_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: orderReturn.order_id,
+          return_id: orderReturn.id,
+          status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
+        },
+      },
+      list: false,
+    }).config({ name: "order-change-query" })
+
+    validationStep({ orderReturn, 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(orderReturn.order_id)
+  }
+)

packages/medusa/src/api/admin/returns/[id]/shipping-method/[action_id]/route.ts

@@ -0,0 +1,44 @@
+import { removeReturnShippingMethodWorkflow } from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../../types/routing"
+
+export const DELETE = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const { id, action_id } = req.params
+
+  const { result: orderPreview } = await removeReturnShippingMethodWorkflow(
+    req.scope
+  ).run({
+    input: {
+      return_id: id,
+      action_id,
+    },
+  })
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "return",
+    variables: {
+      id,
+      filters: {
+        ...req.filterableFields,
+      },
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+  const [orderReturn] = await remoteQuery(queryObject)
+
+  res.json({
+    order_preview: orderPreview,
+    return: orderReturn,
+  })
+}

packages/medusa/src/api/admin/returns/middlewares.ts

@@ -65,6 +65,16 @@ export const adminReturnRoutesMiddlewares: MiddlewareRoute[] = [
       ),
     ],
   },
+  {
+    method: ["DELETE"],
+    matcher: "/admin/returns/:id/shipping-method/:action_id",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
   {
     method: ["POST"],
     matcher: "/admin/returns/:id/request",

packages/modules/order/integration-tests/__tests__/order-exchange.ts

@@ -211,7 +211,7 @@ moduleIntegrationTestRunner({
                 }),
               }),
             ]),
-            shipping_methods: [
+            shipping_methods: expect.arrayContaining([
               expect.objectContaining({
                 name: "return shipping method",
                 amount: 10,
@@ -220,7 +220,7 @@ moduleIntegrationTestRunner({
                 name: "Exchange method",
                 amount: 35,
               }),
-            ],
+            ]),
             difference_due: 14,
           })
         )

packages/modules/order/src/migrations/Migration20240715174100.ts

@@ -0,0 +1,20 @@
+import { Migration } from "@mikro-orm/migrations"
+
+export class Migration20240715102100 extends Migration {
+  async up(): Promise<void> {
+    const sql = `
+      DROP INDEX IF EXISTS "IDX_order_shipping_method_shipping_option_id";
+
+      ALTER TABLE "order_shipping_method"
+        ADD COLUMN if NOT exists "deleted_at" timestamptz NULL;
+
+      CREATE INDEX IF NOT EXISTS "IDX_order_shipping_method_shipping_option_id" ON "order_shipping_method" (
+          shipping_option_id
+      ) WHERE deleted_at IS NULL;
+
+
+    `
+
+    this.addSql(sql)
+  }
+}