Chore/order claims 2 (#8312)

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

@@ -0,0 +1,528 @@
+import {
+  ClaimReason,
+  ClaimType,
+  ContainerRegistrationKeys,
+  ModuleRegistrationName,
+  Modules,
+  RuleOperator,
+} from "@medusajs/utils"
+import { medusaIntegrationTestRunner } from "medusa-test-utils"
+import {
+  adminHeaders,
+  createAdminUser,
+} from "../../../helpers/create-admin-user"
+
+jest.setTimeout(30000)
+
+medusaIntegrationTestRunner({
+  testSuite: ({ dbConnection, getContainer, api }) => {
+    let order, order2
+    let returnShippingOption
+    let shippingProfile
+    let fulfillmentSet
+    let returnReason
+    let inventoryItem
+    let inventoryItemExtra
+    let location
+    let productExtra
+    const shippingProviderId = "manual_test-provider"
+
+    beforeEach(async () => {
+      const container = getContainer()
+      await createAdminUser(dbConnection, adminHeaders, container)
+
+      const region = (
+        await api.post(
+          "/admin/regions",
+          {
+            name: "test-region",
+            currency_code: "usd",
+          },
+          adminHeaders
+        )
+      ).data.region
+
+      const customer = (
+        await api.post(
+          "/admin/customers",
+          {
+            first_name: "joe",
+            email: "joe@admin.com",
+          },
+          adminHeaders
+        )
+      ).data.customer
+
+      const salesChannel = (
+        await api.post(
+          "/admin/sales-channels",
+          {
+            name: "Test channel",
+          },
+          adminHeaders
+        )
+      ).data.sales_channel
+
+      const product = (
+        await api.post(
+          "/admin/products",
+          {
+            title: "Test product",
+            variants: [
+              {
+                title: "Test variant",
+                sku: "test-variant",
+                prices: [
+                  {
+                    currency_code: "usd",
+                    amount: 10,
+                  },
+                ],
+              },
+            ],
+          },
+          adminHeaders
+        )
+      ).data.product
+
+      productExtra = (
+        await api.post(
+          "/admin/products",
+          {
+            title: "Extra product",
+            variants: [
+              {
+                title: "my variant",
+                sku: "variant-sku",
+                prices: [
+                  {
+                    currency_code: "usd",
+                    amount: 123456.1234657890123456789,
+                  },
+                ],
+              },
+            ],
+          },
+          adminHeaders
+        )
+      ).data.product
+
+      returnReason = (
+        await api.post(
+          "/admin/return-reasons",
+          {
+            value: "return-reason-test",
+            label: "Test return reason",
+          },
+          adminHeaders
+        )
+      ).data.return_reason
+
+      const orderModule = container.resolve(ModuleRegistrationName.ORDER)
+
+      order = await orderModule.createOrders({
+        region_id: region.id,
+        email: "foo@bar.com",
+        items: [
+          {
+            title: "Custom Item 2",
+            variant_id: product.variants[0].id,
+            quantity: 2,
+            unit_price: 25,
+          },
+        ],
+        sales_channel_id: salesChannel.id,
+        shipping_address: {
+          first_name: "Test",
+          last_name: "Test",
+          address_1: "Test",
+          city: "Test",
+          country_code: "US",
+          postal_code: "12345",
+          phone: "12345",
+        },
+        billing_address: {
+          first_name: "Test",
+          last_name: "Test",
+          address_1: "Test",
+          city: "Test",
+          country_code: "US",
+          postal_code: "12345",
+        },
+        shipping_methods: [
+          {
+            name: "Test shipping method",
+            amount: 10,
+            data: {},
+            tax_lines: [
+              {
+                description: "shipping Tax 1",
+                tax_rate_id: "tax_usa_shipping",
+                code: "code",
+                rate: 10,
+              },
+            ],
+          },
+        ],
+        currency_code: "usd",
+        customer_id: customer.id,
+      })
+
+      order2 = await orderModule.createOrders({
+        region_id: region.id,
+        email: "foo@bar2.com",
+        items: [
+          {
+            title: "Custom Iasdasd2",
+            quantity: 1,
+            unit_price: 20,
+          },
+        ],
+        sales_channel_id: salesChannel.id,
+        shipping_address: {
+          first_name: "Test",
+          last_name: "Test",
+          address_1: "Test",
+          city: "Test",
+          country_code: "US",
+          postal_code: "12345",
+          phone: "12345",
+        },
+        billing_address: {
+          first_name: "Test",
+          last_name: "Test",
+          address_1: "Test",
+          city: "Test",
+          country_code: "US",
+          postal_code: "12345",
+        },
+        currency_code: "usd",
+        customer_id: customer.id,
+      })
+
+      shippingProfile = (
+        await api.post(
+          `/admin/shipping-profiles`,
+          {
+            name: "Test",
+            type: "default",
+          },
+          adminHeaders
+        )
+      ).data.shipping_profile
+
+      location = (
+        await api.post(
+          `/admin/stock-locations`,
+          {
+            name: "Test location",
+          },
+          adminHeaders
+        )
+      ).data.stock_location
+
+      location = (
+        await api.post(
+          `/admin/stock-locations/${location.id}/fulfillment-sets?fields=*fulfillment_sets`,
+          {
+            name: "Test",
+            type: "test-type",
+          },
+          adminHeaders
+        )
+      ).data.stock_location
+
+      fulfillmentSet = (
+        await api.post(
+          `/admin/fulfillment-sets/${location.fulfillment_sets[0].id}/service-zones`,
+          {
+            name: "Test",
+            geo_zones: [{ type: "country", country_code: "us" }],
+          },
+          adminHeaders
+        )
+      ).data.fulfillment_set
+
+      inventoryItem = (
+        await api.post(
+          `/admin/inventory-items`,
+          { sku: "inv-1234" },
+          adminHeaders
+        )
+      ).data.inventory_item
+
+      await api.post(
+        `/admin/inventory-items/${inventoryItem.id}/location-levels`,
+        {
+          location_id: location.id,
+          stocked_quantity: 2,
+        },
+        adminHeaders
+      )
+
+      inventoryItemExtra = (
+        await api.get(`/admin/inventory-items?sku=variant-sku`, adminHeaders)
+      ).data.inventory_items[0]
+
+      await api.post(
+        `/admin/inventory-items/${inventoryItemExtra.id}/location-levels`,
+        {
+          location_id: location.id,
+          stocked_quantity: 4,
+        },
+        adminHeaders
+      )
+
+      const remoteLink = container.resolve(
+        ContainerRegistrationKeys.REMOTE_LINK
+      )
+
+      await remoteLink.create([
+        {
+          [Modules.STOCK_LOCATION]: {
+            stock_location_id: location.id,
+          },
+          [Modules.FULFILLMENT]: {
+            fulfillment_provider_id: shippingProviderId,
+          },
+        },
+        {
+          [Modules.STOCK_LOCATION]: {
+            stock_location_id: location.id,
+          },
+          [Modules.FULFILLMENT]: {
+            fulfillment_set_id: fulfillmentSet.id,
+          },
+        },
+        {
+          [Modules.SALES_CHANNEL]: {
+            sales_channel_id: salesChannel.id,
+          },
+          [Modules.STOCK_LOCATION]: {
+            stock_location_id: location.id,
+          },
+        },
+        {
+          [Modules.PRODUCT]: {
+            variant_id: product.variants[0].id,
+          },
+          [Modules.INVENTORY]: {
+            inventory_item_id: inventoryItem.id,
+          },
+        },
+        {
+          [Modules.PRODUCT]: {
+            variant_id: productExtra.variants[0].id,
+          },
+          [Modules.INVENTORY]: {
+            inventory_item_id: inventoryItemExtra.id,
+          },
+        },
+      ])
+
+      const shippingOptionPayload = {
+        name: "Return shipping",
+        service_zone_id: fulfillmentSet.service_zones[0].id,
+        shipping_profile_id: shippingProfile.id,
+        provider_id: shippingProviderId,
+        price_type: "flat",
+        type: {
+          label: "Test type",
+          description: "Test description",
+          code: "test-code",
+        },
+        prices: [
+          {
+            currency_code: "usd",
+            amount: 1000,
+          },
+        ],
+        rules: [
+          {
+            operator: RuleOperator.EQ,
+            attribute: "is_return",
+            value: "true",
+          },
+        ],
+      }
+
+      returnShippingOption = (
+        await api.post(
+          "/admin/shipping-options",
+          shippingOptionPayload,
+          adminHeaders
+        )
+      ).data.shipping_option
+
+      const item = order.items[0]
+
+      await api.post(
+        `/admin/orders/${order.id}/fulfillments`,
+        {
+          items: [
+            {
+              id: item.id,
+              quantity: 2,
+            },
+          ],
+        },
+        adminHeaders
+      )
+
+      await api.post(
+        `/admin/orders/${order2.id}/fulfillments`,
+        {
+          items: [
+            {
+              id: order2.items[0].id,
+              quantity: 1,
+            },
+          ],
+        },
+        adminHeaders
+      )
+    })
+
+    describe("Returns lifecycle", () => {
+      it.only("Full flow with 2 orders", async () => {
+        let result = await api.post(
+          "/admin/claims",
+          {
+            order_id: order.id,
+            type: ClaimType.REPLACE,
+            description: "Test",
+          },
+          adminHeaders
+        )
+
+        let r2 = await api.post(
+          "/admin/claims",
+          {
+            order_id: order2.id,
+            type: ClaimType.REFUND,
+          },
+          adminHeaders
+        )
+
+        const claimId2 = r2.data.claim.id
+        const item2 = order2.items[0]
+
+        await api.post(
+          `/admin/claims/${claimId2}/inbound/items`,
+          {
+            items: [
+              {
+                id: item2.id,
+                quantity: 1,
+              },
+            ],
+          },
+          adminHeaders
+        )
+
+        await api.post(
+          `/admin/claims/${claimId2}/inbound/shipping-method`,
+          {
+            shipping_option_id: returnShippingOption.id,
+          },
+          adminHeaders
+        )
+        await api.post(`/admin/claims/${claimId2}/request`, {}, adminHeaders)
+
+        const claimId = result.data.claim.id
+
+        const item = order.items[0]
+
+        result = await api.post(
+          `/admin/claims/${claimId}/inbound/items`,
+          {
+            items: [
+              {
+                id: item.id,
+                reason_id: returnReason.id,
+                quantity: 2,
+              },
+            ],
+          },
+          adminHeaders
+        )
+
+        await api.post(
+          `/admin/claims/${claimId}/inbound/shipping-method`,
+          {
+            shipping_option_id: returnShippingOption.id,
+          },
+          adminHeaders
+        )
+
+        // updated the requested quantity
+        const updateReturnItemActionId =
+          result.data.order_preview.items[0].actions[0].id
+
+        result = await api.post(
+          `/admin/claims/${claimId}/inbound/items/${updateReturnItemActionId}`,
+          {
+            quantity: 1,
+          },
+          adminHeaders
+        )
+
+        // New Items
+        await api.post(
+          `/admin/claims/${claimId}/outbound/items`,
+          {
+            items: [
+              {
+                variant_id: productExtra.variants[0].id,
+                quantity: 2,
+              },
+            ],
+          },
+          adminHeaders
+        )
+
+        // Claim Items
+        await api.post(
+          `/admin/claims/${claimId}/claim-items`,
+          {
+            items: [
+              {
+                id: item.id,
+                reason: ClaimReason.PRODUCTION_FAILURE,
+                quantity: 1,
+              },
+            ],
+          },
+          adminHeaders
+        )
+
+        result = await api.post(
+          `/admin/claims/${claimId}/request`,
+          {},
+          adminHeaders
+        )
+
+        result = (
+          await api.get(
+            `/admin/claims?fields=*claim_items,*additional_items`,
+            adminHeaders
+          )
+        ).data.claims
+        expect(result).toHaveLength(2)
+
+        console.log(
+          JSON.stringify(
+            (
+              await api.get(
+                `/admin/orders?fields=*items,total,summary`,
+                adminHeaders
+              )
+            ).data.orders[0],
+            null,
+            2
+          )
+        )
+      })
+    })
+  },
+})

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

@@ -140,6 +140,12 @@ medusaIntegrationTestRunner({
         },
         currency_code: "usd",
         customer_id: "joe",
+        transactions: [
+          {
+            amount: 20,
+            currency_code: "usd",
+          },
+        ],
       })
 
       shippingProfile = (
@@ -328,6 +334,7 @@ medusaIntegrationTestRunner({
           },
           adminHeaders
         )
+
         await api.post(
           `/admin/returns/${returnId2}/shipping-method`,
           {
@@ -335,6 +342,7 @@ medusaIntegrationTestRunner({
           },
           adminHeaders
         )
+
         await api.post(`/admin/returns/${returnId2}/request`, {}, adminHeaders)
 
         const returnId = result.data.return.id

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

@@ -0,0 +1,59 @@
+import { IOrderModuleService, OrderChangeActionDTO } from "@medusajs/types"
+import { ChangeActionType, ModuleRegistrationName } from "@medusajs/utils"
+import { StepResponse, createStep } from "@medusajs/workflows-sdk"
+
+type CreateOrderClaimItemsInput = {
+  changes: OrderChangeActionDTO[]
+  claimId: string
+}
+
+export const createOrderClaimItemsStep = createStep(
+  "create-claim-items",
+  async (input: CreateOrderClaimItemsInput, { container }) => {
+    const orderModuleService = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    const claimItems = input.changes.map((item) => {
+      let additionalFields
+      if (item.action === ChangeActionType.ITEM_ADD) {
+        additionalFields = {
+          is_additional_item: true,
+        }
+      } else if (item.action === ChangeActionType.WRITE_OFF_ITEM) {
+        additionalFields = {
+          reason: item.details?.reason,
+        }
+      }
+
+      return {
+        claim_id: input.claimId,
+        item_id: item.details?.reference_id! as string,
+        quantity: item.details?.quantity as number,
+        note: item.internal_note,
+        metadata: (item.details?.metadata as Record<string, unknown>) ?? {},
+        ...additionalFields,
+      }
+    })
+
+    const createdClaimItems = await orderModuleService.createOrderClaimItems(
+      claimItems
+    )
+
+    return new StepResponse(
+      createdClaimItems,
+      createdClaimItems.map((i) => i.id)
+    )
+  },
+  async (ids, { container }) => {
+    if (!ids) {
+      return
+    }
+
+    const orderModuleService = container.resolve<IOrderModuleService>(
+      ModuleRegistrationName.ORDER
+    )
+
+    await orderModuleService.deleteOrderClaimItems(ids)
+  }
+)

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

@@ -28,6 +28,7 @@ export const createReturnItemsStep = createStep(
         metadata: (item.details?.metadata as Record<string, unknown>) ?? {},
       } as CreateOrderReturnItemDTO
     })
+
     const createdReturnItems = await orderModuleService.createReturnItems(
       returnItems
     )

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

@@ -5,6 +5,7 @@ export * from "./cancel-order-change"
 export * from "./cancel-orders"
 export * from "./cancel-return"
 export * from "./complete-orders"
+export * from "./create-claim-items"
 export * from "./create-claims"
 export * from "./create-complete-return"
 export * from "./create-exchanges"

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

@@ -45,7 +45,7 @@ export const cancelBeginOrderClaimWorkflow = createWorkflow(
   cancelBeginOrderClaimWorkflowId,
   function (input: WorkflowInput): WorkflowData<void> {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "return_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,

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

@@ -100,7 +100,7 @@ export const orderClaimAddNewItemWorkflow = createWorkflow(
           details: {
             reference_id: lineItems[index].id,
             quantity: item.quantity,
-            unit_price: item.unit_price,
+            unit_price: item.unit_price ?? lineItems[index].unit_price,
             metadata: item.metadata,
           },
         }))

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

@@ -91,6 +91,7 @@ export const orderClaimItemWorkflow = createWorkflow(
           reference_id: orderClaim.id,
           details: {
             reference_id: item.id,
+            reason: item.reason,
             quantity: item.quantity,
           },
         }))

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

@@ -156,6 +156,7 @@ export const orderClaimRequestItemReturnWorkflow = createWorkflow(
           details: {
             reference_id: item.id,
             quantity: item.quantity,
+            reason_id: item.reason_id,
             metadata: item.metadata,
           },
         }))

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

@@ -0,0 +1,361 @@
+import {
+  FulfillmentWorkflow,
+  OrderChangeActionDTO,
+  OrderChangeDTO,
+  OrderClaimDTO,
+  OrderDTO,
+} from "@medusajs/types"
+import { ChangeActionType, Modules, OrderChangeStatus } from "@medusajs/utils"
+import {
+  WorkflowData,
+  createStep,
+  createWorkflow,
+  parallelize,
+  transform,
+  when,
+} from "@medusajs/workflows-sdk"
+import { createRemoteLinkStep, useRemoteQueryStep } from "../../../common"
+import { createFulfillmentWorkflow } from "../../../fulfillment/workflows/create-fulfillment"
+import { createReturnFulfillmentWorkflow } from "../../../fulfillment/workflows/create-return-fulfillment"
+import { previewOrderChangeStep } from "../../steps"
+import { confirmOrderChanges } from "../../steps/confirm-order-changes"
+import { createOrderClaimItemsStep } from "../../steps/create-claim-items"
+import { createReturnItemsStep } from "../../steps/create-return-items"
+import {
+  throwIfIsCancelled,
+  throwIfOrderChangeIsNotActive,
+} from "../../utils/order-validation"
+
+type WorkflowInput = {
+  claim_id: string
+}
+
+const validationStep = createStep(
+  "validate-confirm-claim-request",
+  async function ({
+    order,
+    orderChange,
+    orderClaim,
+  }: {
+    order: OrderDTO
+    orderClaim: OrderClaimDTO
+    orderChange: OrderChangeDTO
+  }) {
+    throwIfIsCancelled(order, "Order")
+    throwIfIsCancelled(orderClaim, "Claim")
+    throwIfOrderChangeIsNotActive({ orderChange })
+  }
+)
+
+function prepareFulfillmentData({
+  order,
+  items,
+  shippingOption,
+  deliveryAddress,
+}: {
+  order: OrderDTO
+  items: any[]
+  shippingOption: {
+    id: string
+    provider_id: string
+    service_zone: {
+      fulfillment_set: {
+        location?: {
+          id: string
+          address: Record<string, any>
+        }
+      }
+    }
+  }
+  deliveryAddress?: Record<string, any>
+}) {
+  const orderItemsMap = new Map<string, Required<OrderDTO>["items"][0]>(
+    order.items!.map((i) => [i.id, i])
+  )
+  const fulfillmentItems = items.map((i) => {
+    const orderItem = orderItemsMap.get(i.item_id)!
+    return {
+      line_item_id: i.item_id,
+      quantity: i.quantity,
+      return_quantity: i.quantity,
+      title: orderItem.variant_title ?? orderItem.title,
+      sku: orderItem.variant_sku || "",
+      barcode: orderItem.variant_barcode || "",
+    } as FulfillmentWorkflow.CreateFulfillmentItemWorkflowDTO
+  })
+
+  const locationId = shippingOption.service_zone.fulfillment_set.location?.id!
+
+  // delivery address is the stock location address
+  const address =
+    deliveryAddress ??
+    shippingOption.service_zone.fulfillment_set.location?.address ??
+    {}
+
+  delete address.id
+
+  return {
+    input: {
+      location_id: locationId,
+      provider_id: shippingOption.provider_id,
+      shipping_option_id: shippingOption.id,
+      items: fulfillmentItems,
+      delivery_address: address,
+      order: order,
+    },
+  }
+}
+
+function transformActionsToItems({ orderChange }) {
+  const claimItems: OrderChangeActionDTO[] = []
+  const returnItems: OrderChangeActionDTO[] = []
+
+  const actions = orderChange.actions ?? []
+  actions.forEach((item) => {
+    if (item.action === ChangeActionType.RETURN_ITEM) {
+      returnItems.push(item)
+    } else if (
+      item.action === ChangeActionType.ITEM_ADD ||
+      item.action === ChangeActionType.WRITE_OFF_ITEM
+    ) {
+      claimItems.push(item)
+    }
+  })
+
+  return {
+    claimItems: {
+      changes: claimItems,
+      claimId: claimItems?.[0]?.claim_id!,
+    },
+    returnItems: {
+      changes: returnItems,
+      returnId: returnItems?.[0]?.return_id!,
+    },
+  }
+}
+
+function extractShippingOption({ orderPreview, orderClaim, returnId }) {
+  if (!orderPreview.shipping_methods?.length) {
+    return
+  }
+
+  let returnShippingMethod
+  let claimShippingMethod
+  for (const shippingMethod of orderPreview.shipping_methods) {
+    const modifiedShippingMethod_ = shippingMethod as any
+    if (!modifiedShippingMethod_.actions) {
+      continue
+    }
+
+    for (const action of modifiedShippingMethod_.actions) {
+      if (action.action === ChangeActionType.SHIPPING_ADD) {
+        if (action.return_id === returnId) {
+          returnShippingMethod = shippingMethod
+        } else if (action.claim_id === orderClaim.id) {
+          claimShippingMethod = shippingMethod
+        }
+      }
+    }
+  }
+
+  return {
+    returnShippingMethod,
+    claimShippingMethod,
+  }
+}
+
+export const confirmClaimRequestWorkflowId = "confirm-claim-request"
+export const confirmClaimRequestWorkflow = createWorkflow(
+  confirmClaimRequestWorkflowId,
+  function (input: WorkflowInput): WorkflowData<OrderDTO> {
+    const orderClaim: OrderClaimDTO = useRemoteQueryStep({
+      entry_point: "order_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",
+        "version",
+        "canceled_at",
+        "items.id",
+        "items.title",
+        "items.variant_title",
+        "items.variant_sku",
+        "items.variant_barcode",
+        "shipping_address.*",
+      ],
+      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",
+        "actions.id",
+        "actions.claim_id",
+        "actions.return_id",
+        "actions.action",
+        "actions.details",
+        "actions.reference",
+        "actions.reference_id",
+        "actions.internal_note",
+      ],
+      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 { claimItems, returnItems } = transform(
+      { orderChange },
+      transformActionsToItems
+    )
+
+    const orderPreview = previewOrderChangeStep(order.id)
+
+    const [createClaimItems, createdReturnItems] = parallelize(
+      createOrderClaimItemsStep(claimItems),
+      createReturnItemsStep(returnItems),
+      confirmOrderChanges({ changes: [orderChange], orderId: order.id })
+    )
+
+    const returnId = transform(
+      { createdReturnItems },
+      ({ createdReturnItems }) => {
+        return createdReturnItems?.[0]?.return_id
+      }
+    )
+
+    const claimId = transform({ createClaimItems }, ({ createClaimItems }) => {
+      return createClaimItems?.[0]?.claim_id
+    })
+
+    const { returnShippingMethod, claimShippingMethod } = transform(
+      { orderPreview, orderClaim, returnId },
+      extractShippingOption
+    )
+
+    when({ claimShippingMethod }, ({ claimShippingMethod }) => {
+      return !!claimShippingMethod
+    }).then(() => {
+      const claim: OrderClaimDTO = useRemoteQueryStep({
+        entry_point: "order_claim",
+        fields: [
+          "id",
+          "version",
+          "canceled_at",
+          "additional_items.id",
+          "additional_items.title",
+          "additional_items.variant_title",
+          "additional_items.variant_sku",
+          "additional_items.variant_barcode",
+        ],
+        variables: { id: claimId },
+        list: false,
+        throw_if_key_not_found: true,
+      }).config({ name: "claim-query" })
+
+      const claimShippingOption = useRemoteQueryStep({
+        entry_point: "shipping_options",
+        fields: [
+          "id",
+          "provider_id",
+          "service_zone.fulfillment_set.location.id",
+          "service_zone.fulfillment_set.location.address.*",
+        ],
+        variables: {
+          id: claimShippingMethod.shipping_option_id,
+        },
+        list: false,
+        throw_if_key_not_found: true,
+      }).config({ name: "claim-shipping-option" })
+
+      const fulfillmentData = transform(
+        {
+          order,
+          items: claim.additional_items! ?? [],
+          shippingOption: claimShippingOption,
+          deliveryAddress: order.shipping_address,
+        },
+        prepareFulfillmentData
+      )
+
+      const fulfillment = createFulfillmentWorkflow.runAsStep(fulfillmentData)
+
+      const link = transform({ fulfillment, order }, (data) => {
+        return [
+          {
+            [Modules.ORDER]: { order_id: data.order.id },
+            [Modules.FULFILLMENT]: { fulfillment_id: data.fulfillment.id },
+          },
+        ]
+      })
+
+      createRemoteLinkStep(link).config({
+        name: "claim-shipping-fulfillment-link",
+      })
+    })
+
+    when({ returnShippingMethod }, ({ returnShippingMethod }) => {
+      return !!returnShippingMethod
+    }).then(() => {
+      const returnShippingOption = useRemoteQueryStep({
+        entry_point: "shipping_options",
+        fields: [
+          "id",
+          "provider_id",
+          "service_zone.fulfillment_set.location.id",
+          "service_zone.fulfillment_set.location.address.*",
+        ],
+        variables: {
+          id: returnShippingMethod.shipping_option_id,
+        },
+        list: false,
+        throw_if_key_not_found: true,
+      }).config({ name: "claim-return-shipping-option" })
+
+      const fulfillmentData = transform(
+        {
+          order,
+          items: order.items!,
+          shippingOption: returnShippingOption,
+        },
+        prepareFulfillmentData
+      )
+
+      const returnFulfillment =
+        createReturnFulfillmentWorkflow.runAsStep(fulfillmentData)
+
+      const returnLink = transform(
+        { returnId, fulfillment: returnFulfillment },
+        (data) => {
+          return [
+            {
+              [Modules.ORDER]: { return_id: data.returnId },
+              [Modules.FULFILLMENT]: { fulfillment_id: data.fulfillment.id },
+            },
+          ]
+        }
+      )
+
+      createRemoteLinkStep(returnLink).config({
+        name: "claim-return-shipping-fulfillment-link",
+      })
+    })
+
+    return orderPreview
+  }
+)

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

@@ -48,7 +48,7 @@ export const createClaimShippingMethodWorkflow = createWorkflow(
     custom_price?: BigNumberInput
   }): WorkflowData<OrderDTO> {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,
@@ -115,8 +115,8 @@ export const createClaimShippingMethodWorkflow = createWorkflow(
           name: option.name,
           version: orderChange.version,
           order_id: data.orderClaim.order_id,
-          return_id: data.orderClaim.id,
+          return_id: input.return_id,
-          claim_id: data.input.claim_id,
+          claim_id: data.orderClaim.id,
         }
       }
     )
@@ -156,8 +156,8 @@ export const createClaimShippingMethodWorkflow = createWorkflow(
           reference_id: createdMethod.id,
           amount: methodPrice,
           order_id: order.id,
-          return_id: orderClaim.id,
+          return_id: input.return_id,
-          claim_id: input.claim_id,
+          claim_id: orderClaim.id,
         }
       }
     )

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

@@ -59,7 +59,7 @@ export const removeItemClaimActionWorkflow = createWorkflow(
     input: WorkflowData<OrderWorkflow.DeleteOrderClaimItemActionWorkflowInput>
   ): WorkflowData<OrderDTO> {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,

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

@@ -59,7 +59,7 @@ export const removeClaimShippingMethodWorkflow = createWorkflow(
     input: WorkflowData<OrderWorkflow.DeleteClaimShippingMethodWorkflowInput>
   ): WorkflowData {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,

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

@@ -63,7 +63,7 @@ export const updateClaimAddItemWorkflow = createWorkflow(
     input: WorkflowData<OrderWorkflow.UpdateClaimAddNewItemWorkflowInput>
   ): WorkflowData<OrderDTO> {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,

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

@@ -63,7 +63,7 @@ export const updateClaimItemWorkflow = createWorkflow(
     input: WorkflowData<OrderWorkflow.UpdateClaimItemWorkflowInput>
   ): WorkflowData<OrderDTO> {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,

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

@@ -61,7 +61,7 @@ export const updateClaimShippingMethodWorkflow = createWorkflow(
     input: WorkflowData<OrderWorkflow.UpdateClaimShippingMethodWorkflowInput>
   ): WorkflowData {
     const orderClaim: OrderClaimDTO = useRemoteQueryStep({
-      entry_point: "claim",
+      entry_point: "order_claim",
       fields: ["id", "status", "order_id", "canceled_at"],
       variables: { id: input.claim_id },
       list: false,

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

@@ -8,6 +8,7 @@ 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/confirm-claim-request"
 export * from "./claim/create-claim-shipping-method"
 export * from "./claim/remove-claim-item-action"
 export * from "./claim/remove-claim-shipping-method"

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

@@ -4,12 +4,7 @@ import {
   OrderDTO,
   ReturnDTO,
 } from "@medusajs/types"
-import {
+import { ChangeActionType, Modules, OrderChangeStatus } from "@medusajs/utils"
-  ChangeActionType,
-  MedusaError,
-  Modules,
-  OrderChangeStatus,
-} from "@medusajs/utils"
 import {
   WorkflowData,
   createStep,
@@ -84,7 +79,7 @@ function prepareFulfillmentData({
   })
 
   const locationId =
-    returnShippingOption.service_zone.fulfillment_set.location?.id
+    returnShippingOption.service_zone.fulfillment_set.location?.id!
 
   // delivery address is the stock location address
   const address =
@@ -92,13 +87,6 @@ function prepareFulfillmentData({
 
   delete address.id
 
-  if (!locationId) {
-    throw new MedusaError(
-      MedusaError.Types.INVALID_DATA,
-      `Cannot create return without stock location, either provide a location or you should link the shipping option ${returnShippingOption.id} to a stock location.`
-    )
-  }
-
   return {
     input: {
       location_id: locationId,
@@ -111,6 +99,31 @@ function prepareFulfillmentData({
   }
 }
 
+function extractReturnShippingOptionId({ orderPreview, orderReturn }) {
+  if (!orderPreview.shipping_methods?.length) {
+    return
+  }
+
+  let returnShippingMethod
+  for (const shippingMethod of orderPreview.shipping_methods) {
+    const modifiedShippingMethod_ = shippingMethod as any
+    if (!modifiedShippingMethod_.actions) {
+      continue
+    }
+
+    for (const action of modifiedShippingMethod_.actions) {
+      if (
+        action.action === ChangeActionType.SHIPPING_ADD &&
+        action.return_id === orderReturn.id
+      ) {
+        returnShippingMethod = shippingMethod
+        break
+      }
+    }
+  }
+  return returnShippingMethod.shipping_option_id
+}
+
 export const confirmReturnRequestWorkflowId = "confirm-return-request"
 export const confirmReturnRequestWorkflow = createWorkflow(
   confirmReturnRequestWorkflowId,
@@ -169,36 +182,16 @@ export const confirmReturnRequestWorkflow = createWorkflow(
 
     validationStep({ order, orderReturn, orderChange })
 
+    const orderPreview = previewOrderChangeStep(order.id)
+
     const createdReturnItems = createReturnItemsStep({
       returnId: orderReturn.id,
       changes: returnItemActions,
     })
 
-    confirmOrderChanges({ changes: [orderChange], orderId: order.id })
-
-    const returnModified = useRemoteQueryStep({
-      entry_point: "return",
-      fields: [
-        "id",
-        "status",
-        "order_id",
-        "canceled_at",
-        "shipping_methods.shipping_option_id",
-      ],
-      variables: { id: input.return_id },
-      list: false,
-      throw_if_key_not_found: true,
-    }).config({ name: "return-query" })
-
     const returnShippingOptionId = transform(
-      { returnModified },
+      { orderPreview, orderReturn },
-      ({ returnModified }) => {
+      extractReturnShippingOptionId
-        if (!returnModified.shipping_methods?.length) {
-          return
-        }
-
-        return returnModified.shipping_methods[0].shipping_option_id
-      }
     )
 
     when({ returnShippingOptionId }, ({ returnShippingOptionId }) => {
@@ -242,6 +235,8 @@ export const confirmReturnRequestWorkflow = createWorkflow(
       createRemoteLinkStep(link)
     })
 
-    return previewOrderChangeStep(order.id)
+    confirmOrderChanges({ changes: [orderChange], orderId: order.id })
+
+    return orderPreview
   }
 )

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

@@ -97,7 +97,7 @@ export const updateRequestItemReturnWorkflow = createWorkflow(
       variables: {
         filters: {
           order_id: orderReturn.order_id,
-          return_id: orderReturn.id,
+          claim_id: input.claim_id,
           status: [OrderChangeStatus.PENDING, OrderChangeStatus.REQUESTED],
         },
       },

packages/core/types/src/order/common.ts

@@ -3,6 +3,7 @@ import { OperatorMap } from "../dal/utils"
 import { FulfillmentDTO } from "../fulfillment"
 import { PaymentCollectionDTO } from "../payment"
 import { BigNumberInput, BigNumberRawValue, BigNumberValue } from "../totals"
+import { ClaimReason } from "./mutations"
 
 export type ChangeActionType =
   | "CANCEL"
@@ -1156,6 +1157,40 @@ export interface OrderReturnItemDTO {
   updated_at?: Date | string
 }
 
+export interface OrderClaimItemDTO {
+  id: string
+  claim_id: string
+  order_id: string
+  item_id: string
+  quantity: number
+  reason: ClaimReason
+  raw_quantity: BigNumberRawValue
+  metadata?: Record<string, unknown> | null
+  created_at?: Date | string
+  updated_at?: Date | string
+}
+
+export interface OrderClaimItemImageDTO {
+  id: string
+  claim_item_id: string
+  url: string
+  metadata?: Record<string, unknown> | null
+  created_at?: Date | string
+  updated_at?: Date | string
+}
+
+export interface OrderExchangeItemDTO {
+  id: string
+  exchange_id: string
+  order_id: string
+  item_id: string
+  quantity: number
+  raw_quantity: BigNumberRawValue
+  metadata?: Record<string, unknown> | null
+  created_at?: Date | string
+  updated_at?: Date | string
+}
+
 export interface OrderClaimDTO
   extends Omit<OrderDTO, "status" | "version" | "items"> {
   order_id: string
@@ -1341,6 +1376,9 @@ export interface OrderChangeActionDTO {
    * The ID of the associated order
    */
   order_id: string | null
+  return_id: string | null
+  claim_id: string | null
+  exchange_id: string | null
   /**
    * The associated order
    *

packages/core/types/src/order/mutations.ts

@@ -482,6 +482,32 @@ export interface CreateOrderReturnItemDTO {
   metadata?: Record<string, unknown> | null
 }
 
+export interface CreateOrderClaimItemDTO {
+  claim_id: string
+  item_id: string
+  reason?: ClaimReason
+  is_additional_item?: boolean
+  quantity?: BigNumberInput
+  note?: string
+  metadata?: Record<string, unknown> | null
+}
+
+export interface CreateOrderExchangeItemDTO {
+  exchange_id: string
+  item_id: string
+  quantity?: BigNumberInput
+  note?: string
+  metadata?: Record<string, unknown> | null
+}
+
+export interface CreateOrderExchangeItemDTO {
+  exchange_id: string
+  item_id: string
+  quantity?: BigNumberInput
+  note?: string
+  metadata?: Record<string, unknown> | null
+}
+
 export interface UpdateOrderReturnWithSelectorDTO {
   selector: Partial<ReturnDTO>
   data: Partial<UpdateReturnDTO>
@@ -510,7 +536,7 @@ export type ClaimReason =
 export interface CreateOrderClaimDTO extends BaseOrderBundledActionsDTO {
   type: OrderClaimType
   claim_items?: (BaseOrderBundledItemActionsDTO & {
-    reason: ClaimReason
+    reason?: ClaimReason
     images?: {
       url: string
       metadata?: Record<string, unknown> | null

packages/core/types/src/order/service.ts

@@ -22,8 +22,10 @@ import {
   OrderChangeDTO,
   OrderChangeReturn,
   OrderClaimDTO,
+  OrderClaimItemDTO,
   OrderDTO,
   OrderExchangeDTO,
+  OrderExchangeItemDTO,
   OrderItemDTO,
   OrderLineItemAdjustmentDTO,
   OrderLineItemDTO,
@@ -48,8 +50,10 @@ import {
   CreateOrderChangeActionDTO,
   CreateOrderChangeDTO,
   CreateOrderClaimDTO,
+  CreateOrderClaimItemDTO,
   CreateOrderDTO,
   CreateOrderExchangeDTO,
+  CreateOrderExchangeItemDTO,
   CreateOrderLineItemDTO,
   CreateOrderLineItemTaxLineDTO,
   CreateOrderReturnDTO,
@@ -1889,6 +1893,26 @@ export interface IOrderModuleService extends IModuleService {
     sharedContext?: Context
   ): Promise<OrderReturnItemDTO[]>
 
+  createOrderClaimItems(
+    data: CreateOrderClaimItemDTO,
+    sharedContext?: Context
+  ): Promise<OrderClaimItemDTO>
+
+  createOrderClaimItems(
+    data: CreateOrderClaimItemDTO[],
+    sharedContext?: Context
+  ): Promise<OrderClaimItemDTO[]>
+
+  createOrderExchangeItems(
+    data: CreateOrderExchangeItemDTO,
+    sharedContext?: Context
+  ): Promise<OrderExchangeItemDTO>
+
+  createOrderExchangeItems(
+    data: CreateOrderExchangeItemDTO[],
+    sharedContext?: Context
+  ): Promise<OrderExchangeItemDTO[]>
+
   createReturns(
     data: CreateOrderReturnDTO,
     sharedContext?: Context
@@ -1959,6 +1983,13 @@ export interface IOrderModuleService extends IModuleService {
 
   deleteOrderClaims(ids: string[], sharedContext?: Context): Promise<void>
 
+  deleteOrderClaimItems(ids: string[], sharedContext?: Context): Promise<void>
+
+  deleteOrderClaimItemImages(
+    ids: string[],
+    sharedContext?: Context
+  ): Promise<void>
+
   softDeleteOrderClaims<TReturnableLinkableKeys extends string = string>(
     ids: string[],
     config?: SoftDeleteReturn<TReturnableLinkableKeys>,
@@ -1999,6 +2030,11 @@ export interface IOrderModuleService extends IModuleService {
 
   deleteOrderExchanges(ids: string[], sharedContext?: Context): Promise<void>
 
+  deleteOrderExchangeItems(
+    ids: string[],
+    sharedContext?: Context
+  ): Promise<void>
+
   softDeleteOrderExchanges<TReturnableLinkableKeys extends string = string>(
     ids: string[],
     config?: SoftDeleteReturn<TReturnableLinkableKeys>,

packages/core/types/src/workflow/order/items.ts

@@ -1,3 +1,4 @@
+import { ClaimReason } from "../../order/mutations"
 import { BigNumberInput } from "../../totals"
 
 interface NewItem {
@@ -63,7 +64,7 @@ export interface UpdateExchangeAddItemWorkflowInput {
 
 export interface OrderClaimItemWorkflowInput {
   claim_id: string
-  items: ExistingItem[]
+  items: (ExistingItem & { reason?: ClaimReason })[]
 }
 
 export interface UpdateClaimItemWorkflowInput {
@@ -71,6 +72,7 @@ export interface UpdateClaimItemWorkflowInput {
   action_id: string
   data: {
     quantity?: BigNumberInput
+    reason_id?: ClaimReason
     internal_note?: string | null
   }
 }

packages/medusa/src/api/admin/claims/[id]/claim-items/[action_id]/route.ts

@@ -29,7 +29,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {
@@ -65,7 +65,7 @@ export const DELETE = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {

packages/medusa/src/api/admin/claims/[id]/claim-items/route.ts

@@ -22,7 +22,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {

packages/medusa/src/api/admin/claims/[id]/inbound/items/[action_id]/route.ts

@@ -10,6 +10,7 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../../../../../types/routing"
+import { defaultAdminDetailsReturnFields } from "../../../../../returns/query-config"
 import { AdminPostReturnsRequestItemsActionReqSchemaType } from "../../../../../returns/validators"
 
 export const POST = async (
@@ -22,7 +23,7 @@ export const POST = async (
 
   const [claim] = await remoteQuery(
     remoteQueryObjectFromString({
-      entryPoint: "claim",
+      entryPoint: "order_claim",
       variables: {
         id,
       },
@@ -38,6 +39,7 @@ export const POST = async (
     input: {
       data: { ...req.validatedBody },
       return_id: claim.return_id,
+      claim_id: claim.id,
       action_id,
     },
   })
@@ -45,12 +47,9 @@ export const POST = async (
   const queryObject = remoteQueryObjectFromString({
     entryPoint: "return",
     variables: {
-      id,
+      id: claim.return_id,
-      filters: {
-        ...req.filterableFields,
-      },
     },
-    fields: req.remoteQueryConfig.fields,
+    fields: defaultAdminDetailsReturnFields,
   })
 
   const [orderReturn] = await remoteQuery(queryObject)

packages/medusa/src/api/admin/claims/[id]/inbound/items/route.ts

@@ -8,6 +8,7 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../../../../types/routing"
+import { defaultAdminDetailsReturnFields } from "../../../../returns/query-config"
 import { AdminPostReturnsRequestItemsReqSchemaType } from "../../../../returns/validators"
 
 export const POST = async (
@@ -20,7 +21,7 @@ export const POST = async (
 
   const [claim] = await remoteQuery(
     remoteQueryObjectFromString({
-      entryPoint: "claim",
+      entryPoint: "order_claim",
       variables: {
         id,
       },
@@ -33,18 +34,19 @@ export const POST = async (
   )
 
   const { result } = await orderClaimRequestItemReturnWorkflow(req.scope).run({
-    input: { ...req.validatedBody, return_id: claim.return_id, claim_id: id },
+    input: {
+      ...req.validatedBody,
+      return_id: claim.return_id,
+      claim_id: id,
+    },
   })
 
   const queryObject = remoteQueryObjectFromString({
     entryPoint: "return",
     variables: {
-      id,
+      id: claim.return_id,
-      filters: {
-        ...req.filterableFields,
-      },
     },
-    fields: req.remoteQueryConfig.fields,
+    fields: defaultAdminDetailsReturnFields,
   })
 
   const [orderReturn] = await remoteQuery(queryObject)

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

@@ -10,6 +10,7 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../../../../../types/routing"
+import { defaultAdminDetailsReturnFields } from "../../../../../returns/query-config"
 import { AdminPostClaimsShippingActionReqSchemaType } from "../../../../validators"
 
 export const POST = async (
@@ -22,7 +23,7 @@ export const POST = async (
 
   const [claim] = await remoteQuery(
     remoteQueryObjectFromString({
-      entryPoint: "claim",
+      entryPoint: "order_claim",
       variables: {
         id,
       },
@@ -43,7 +44,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {
@@ -71,7 +72,7 @@ export const DELETE = async (
 
   const [claim] = await remoteQuery(
     remoteQueryObjectFromString({
-      entryPoint: "claim",
+      entryPoint: "order_claim",
       variables: {
         id,
       },
@@ -93,19 +94,17 @@ export const DELETE = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "return",
     variables: {
-      id,
+      id: claim.return_id,
-      filters: {
-        ...req.filterableFields,
-      },
     },
-    fields: req.remoteQueryConfig.fields,
+    fields: defaultAdminDetailsReturnFields,
   })
-  const [orderClaim] = await remoteQuery(queryObject)
+
+  const [orderReturn] = await remoteQuery(queryObject)
 
   res.json({
     order_preview: orderPreview,
-    claim: orderClaim,
+    return: orderReturn,
   })
 }

packages/medusa/src/api/admin/claims/[id]/inbound/shipping-method/route.ts

@@ -8,6 +8,7 @@ import {
   AuthenticatedMedusaRequest,
   MedusaResponse,
 } from "../../../../../../types/routing"
+import { defaultAdminDetailsReturnFields } from "../../../../returns/query-config"
 import { AdminPostReturnsShippingReqSchemaType } from "../../../../returns/validators"
 
 export const POST = async (
@@ -20,7 +21,7 @@ export const POST = async (
 
   const [claim] = await remoteQuery(
     remoteQueryObjectFromString({
-      entryPoint: "claim",
+      entryPoint: "order_claim",
       variables: {
         id,
       },
@@ -33,24 +34,25 @@ export const POST = async (
   )
 
   const { result } = await createClaimShippingMethodWorkflow(req.scope).run({
-    input: { ...req.validatedBody, return_id: claim.return_id, claim_id: id },
+    input: {
+      ...req.validatedBody,
+      return_id: claim.return_id,
+      claim_id: id,
+    },
   })
 
   const queryObject = remoteQueryObjectFromString({
     entryPoint: "return",
     variables: {
-      id,
+      id: claim.return_id,
-      filters: {
-        ...req.filterableFields,
-      },
     },
-    fields: req.remoteQueryConfig.fields,
+    fields: defaultAdminDetailsReturnFields,
   })
 
-  const [orderClaim] = await remoteQuery(queryObject)
+  const [orderReturn] = await remoteQuery(queryObject)
 
   res.json({
     order_preview: result,
-    return: orderClaim,
+    return: orderReturn,
   })
 }

packages/medusa/src/api/admin/claims/[id]/outbound/items/[action_id]/route.ts

@@ -29,7 +29,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {
@@ -65,7 +65,7 @@ export const DELETE = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {

packages/medusa/src/api/admin/claims/[id]/outbound/items/route.ts

@@ -23,7 +23,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {

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

@@ -29,7 +29,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {
@@ -65,7 +65,7 @@ export const DELETE = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {

packages/medusa/src/api/admin/claims/[id]/outbound/shipping-method/route.ts

@@ -22,7 +22,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id,
       filters: {

packages/medusa/src/api/admin/claims/[id]/request/route.ts

@@ -0,0 +1,40 @@
+import { confirmClaimRequestWorkflow } from "@medusajs/core-flows"
+import {
+  ContainerRegistrationKeys,
+  remoteQueryObjectFromString,
+} from "@medusajs/utils"
+import {
+  AuthenticatedMedusaRequest,
+  MedusaResponse,
+} from "../../../../../types/routing"
+
+export const POST = async (
+  req: AuthenticatedMedusaRequest,
+  res: MedusaResponse
+) => {
+  const { id } = req.params
+
+  const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
+
+  const { result } = await confirmClaimRequestWorkflow(req.scope).run({
+    input: { claim_id: id },
+  })
+
+  const queryObject = remoteQueryObjectFromString({
+    entryPoint: "order_claim",
+    variables: {
+      id,
+      filters: {
+        ...req.filterableFields,
+      },
+    },
+    fields: req.remoteQueryConfig.fields,
+  })
+
+  const [orderClaim] = await remoteQuery(queryObject)
+
+  res.json({
+    order_preview: result,
+    claim: orderClaim,
+  })
+}

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

@@ -5,8 +5,8 @@ import * as QueryConfig from "./query-config"
 import {
   AdminGetOrdersOrderParams,
   AdminGetOrdersParams,
+  AdminPostClaimItemsReqSchema,
   AdminPostClaimsAddItemsReqSchema,
-  AdminPostClaimsConfirmRequestReqSchema,
   AdminPostClaimsRequestItemsActionReqSchema,
   AdminPostClaimsRequestReturnItemsReqSchema,
   AdminPostClaimsShippingActionReqSchema,
@@ -51,7 +51,7 @@ export const adminClaimRoutesMiddlewares: MiddlewareRoute[] = [
     method: ["POST"],
     matcher: "/admin/claims/:id/claim-items",
     middlewares: [
-      validateAndTransformBody(AdminPostClaimsRequestReturnItemsReqSchema),
+      validateAndTransformBody(AdminPostClaimItemsReqSchema),
       validateAndTransformQuery(
         AdminGetOrdersOrderParams,
         QueryConfig.retrieveTransformQueryConfig
@@ -214,7 +214,6 @@ export const adminClaimRoutesMiddlewares: MiddlewareRoute[] = [
     method: ["POST"],
     matcher: "/admin/claims/:id/request",
     middlewares: [
-      validateAndTransformBody(AdminPostClaimsConfirmRequestReqSchema),
       validateAndTransformQuery(
         AdminGetOrdersOrderParams,
         QueryConfig.retrieveTransformQueryConfig
@@ -223,7 +222,17 @@ export const adminClaimRoutesMiddlewares: MiddlewareRoute[] = [
   },
   {
     method: ["DELETE"],
-    matcher: "/admin/claims/:id/request",
+    matcher: "/admin/claims/:id",
     middlewares: [],
   },
+  {
+    method: ["POST"],
+    matcher: "/admin/claims/:id/cancel",
+    middlewares: [
+      validateAndTransformQuery(
+        AdminGetOrdersOrderParams,
+        QueryConfig.retrieveTransformQueryConfig
+      ),
+    ],
+  },
 ]

packages/medusa/src/api/admin/claims/query-config.ts

@@ -2,12 +2,10 @@ export const defaultAdminClaimFields = [
   "id",
   "type",
   "order_id",
-  "exchange_id",
+  "return_id",
-  "claim_id",
   "display_id",
   "location_id",
   "order_version",
-  "status",
   "refund_amount",
   "created_at",
   "updated_at",
@@ -15,8 +13,9 @@ export const defaultAdminClaimFields = [
 
 export const defaultAdminDetailsClaimFields = [
   ...defaultAdminClaimFields,
-  "items.*",
+  "additional_items.*",
-  "items.reason.*",
+  "claim_items.*",
+  "claim_items.reason.*",
 ]
 
 export const retrieveTransformQueryConfig = {

packages/medusa/src/api/admin/claims/route.ts

@@ -18,7 +18,7 @@ export const GET = async (
   const remoteQuery = req.scope.resolve(ContainerRegistrationKeys.REMOTE_QUERY)
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claims",
+    entryPoint: "order_claims",
     variables: {
       filters: {
         ...req.filterableFields,
@@ -52,7 +52,7 @@ export const POST = async (
   })
 
   const queryObject = remoteQueryObjectFromString({
-    entryPoint: "claim",
+    entryPoint: "order_claim",
     variables: {
       id: result.claim_id,
       filters: {

packages/medusa/src/api/admin/claims/validators.ts

@@ -1,4 +1,4 @@
-import { ClaimType } from "@medusajs/utils"
+import { ClaimReason, ClaimType } from "@medusajs/utils"
 import { z } from "zod"
 import {
   createFindParams,
@@ -150,9 +150,9 @@ export const AdminPostClaimItemsReqSchema = z.object({
     z.object({
       id: z.string(),
       quantity: z.number(),
+      reason: z.nativeEnum(ClaimReason).optional(),
       description: z.string().optional(),
       internal_note: z.string().optional(),
-      metadata: z.record(z.unknown()).optional(),
     })
   ),
 })
@@ -174,6 +174,7 @@ export type AdminPostClaimsRequestItemsActionReqSchemaType = z.infer<
 
 export const AdminPostClaimsItemsActionReqSchema = z.object({
   quantity: z.number().optional(),
+  reason: z.nativeEnum(ClaimReason).nullish().optional(),
   internal_note: z.string().nullish().optional(),
 })
 

packages/medusa/src/api/middlewares.ts

@@ -1,6 +1,7 @@
 import { defineMiddlewares } from "../utils/define-middlewares"
 import { adminApiKeyRoutesMiddlewares } from "./admin/api-keys/middlewares"
 import { adminCampaignRoutesMiddlewares } from "./admin/campaigns/middlewares"
+import { adminClaimRoutesMiddlewares } from "./admin/claims/middlewares"
 import { adminCollectionRoutesMiddlewares } from "./admin/collections/middlewares"
 import { adminCurrencyRoutesMiddlewares } from "./admin/currencies/middlewares"
 import { adminCustomerGroupRoutesMiddlewares } from "./admin/customer-groups/middlewares"
@@ -17,13 +18,14 @@ import { adminPaymentRoutesMiddlewares } from "./admin/payments/middlewares"
 import { adminPriceListsRoutesMiddlewares } from "./admin/price-lists/middlewares"
 import { adminPricePreferencesRoutesMiddlewares } from "./admin/price-preferences/middlewares"
 import { adminProductCategoryRoutesMiddlewares } from "./admin/product-categories/middlewares"
-import { adminProductTypeRoutesMiddlewares } from "./admin/product-types/middlewares"
 import { adminProductTagRoutesMiddlewares } from "./admin/product-tags/middlewares"
+import { adminProductTypeRoutesMiddlewares } from "./admin/product-types/middlewares"
 import { adminProductRoutesMiddlewares } from "./admin/products/middlewares"
 import { adminPromotionRoutesMiddlewares } from "./admin/promotions/middlewares"
 import { adminRegionRoutesMiddlewares } from "./admin/regions/middlewares"
 import { adminReservationRoutesMiddlewares } from "./admin/reservations/middlewares"
 import { adminReturnReasonRoutesMiddlewares } from "./admin/return-reasons/middlewares"
+import { adminReturnRoutesMiddlewares } from "./admin/returns/middlewares"
 import { adminSalesChannelRoutesMiddlewares } from "./admin/sales-channels/middlewares"
 import { adminShippingOptionRoutesMiddlewares } from "./admin/shipping-options/middlewares"
 import { adminShippingProfilesMiddlewares } from "./admin/shipping-profiles/middlewares"
@@ -35,6 +37,7 @@ import { adminUploadRoutesMiddlewares } from "./admin/uploads/middlewares"
 import { adminUserRoutesMiddlewares } from "./admin/users/middlewares"
 import { adminWorkflowsExecutionsMiddlewares } from "./admin/workflows-executions/middlewares"
 import { authRoutesMiddlewares } from "./auth/middlewares"
+
 import { hooksRoutesMiddlewares } from "./hooks/middlewares"
 import { storeCartRoutesMiddlewares } from "./store/carts/middlewares"
 import { storeCollectionRoutesMiddlewares } from "./store/collections/middlewares"
@@ -48,7 +51,6 @@ import { storeProductRoutesMiddlewares } from "./store/products/middlewares"
 import { storeRegionRoutesMiddlewares } from "./store/regions/middlewares"
 import { storeReturnReasonRoutesMiddlewares } from "./store/return-reasons/middlewares"
 import { storeShippingOptionRoutesMiddlewares } from "./store/shipping-options/middlewares"
-import { adminReturnRoutesMiddlewares } from "./admin/returns/middlewares"
 
 export default defineMiddlewares([
   ...adminCustomerGroupRoutesMiddlewares,
@@ -103,4 +105,5 @@ export default defineMiddlewares([
   ...storeProductRoutesMiddlewares,
   ...storeReturnReasonRoutesMiddlewares,
   ...adminReturnReasonRoutesMiddlewares,
+  ...adminClaimRoutesMiddlewares,
 ])

packages/modules/order/integration-tests/__tests__/index.spec.ts

@@ -1,7 +1,7 @@
-import { moduleIntegrationTestRunner } from "medusa-test-utils"
 import { IOrderModuleService } from "@medusajs/types"
 import { Module, Modules } from "@medusajs/utils"
 import { OrderModuleService } from "@services"
+import { moduleIntegrationTestRunner } from "medusa-test-utils"
 
 moduleIntegrationTestRunner<IOrderModuleService>({
   moduleName: Modules.ORDER,
@@ -31,7 +31,10 @@ moduleIntegrationTestRunner<IOrderModuleService>({
           "return",
           "returnItem",
           "orderClaim",
+          "orderClaimItem",
+          "orderClaimItemImage",
           "orderExchange",
+          "orderExchangeItem",
         ])
 
         Object.keys(linkable).forEach((key) => {
@@ -183,6 +186,22 @@ moduleIntegrationTestRunner<IOrderModuleService>({
               field: "orderClaim",
             },
           },
+          orderClaimItem: {
+            id: {
+              field: "orderClaimItem",
+              linkable: "order_claim_item_id",
+              primaryKey: "id",
+              serviceName: "order",
+            },
+          },
+          orderClaimItemImage: {
+            id: {
+              field: "orderClaimItemImage",
+              linkable: "order_claim_item_image_id",
+              primaryKey: "id",
+              serviceName: "order",
+            },
+          },
           orderExchange: {
             id: {
               linkable: "order_exchange_id",
@@ -191,6 +210,14 @@ moduleIntegrationTestRunner<IOrderModuleService>({
               field: "orderExchange",
             },
           },
+          orderExchangeItem: {
+            id: {
+              field: "orderExchangeItem",
+              linkable: "order_exchange_item_id",
+              primaryKey: "id",
+              serviceName: "order",
+            },
+          },
         })
       })
     })

packages/modules/order/src/models/claim-item-image.ts

@@ -33,7 +33,7 @@ const ClaimItemIdIndex = createPsqlIndexStatementHelper({
 
 @Entity({ tableName: "order_claim_item_image" })
 @Filter(DALUtils.mikroOrmSoftDeletableFilterOptions)
-export default class ClaimItemImage {
+export default class OrderClaimItemImage {
   [OptionalProps]?: OptionalClaimItemImageProps
 
   @PrimaryKey({ columnType: "text" })

packages/modules/order/src/models/claim-item.ts

@@ -20,7 +20,7 @@ import {
   Rel,
 } from "@mikro-orm/core"
 import Claim from "./claim"
-import ClaimItemImage from "./claim-item-image"
+import OrderClaimItemImage from "./claim-item-image"
 import LineItem from "./line-item"
 
 type OptionalLineItemProps = DAL.ModelDateColumns
@@ -50,10 +50,10 @@ export default class OrderClaimItem {
   @PrimaryKey({ columnType: "text" })
   id: string
 
-  @OneToMany(() => ClaimItemImage, (ci) => ci.item, {
+  @OneToMany(() => OrderClaimItemImage, (ci) => ci.item, {
     cascade: [Cascade.PERSIST, Cascade.REMOVE],
   })
-  images = new Collection<Rel<ClaimItemImage>>(this)
+  images = new Collection<Rel<OrderClaimItemImage>>(this)
 
   @Enum({ items: () => ClaimReason, nullable: true })
   reason: Rel<ClaimReason> | null = null
@@ -123,7 +123,7 @@ export default class OrderClaimItem {
   @BeforeCreate()
   onCreate() {
     this.id = generateEntityId(this.id, "claitem")
-    this.claim_id = this.claim?.id
+    this.claim_id ??= this.claim?.id
   }
 
   @OnInit()

packages/modules/order/src/models/exchange.ts

@@ -19,7 +19,7 @@ import {
   Property,
   Rel,
 } from "@mikro-orm/core"
-import { ExchangeItem, Transaction } from "@models"
+import { OrderExchangeItem, Transaction } from "@models"
 import Order from "./order"
 import OrderShippingMethod from "./order-shipping-method"
 import Return from "./return"
@@ -107,10 +107,10 @@ export default class OrderExchange {
   @Property({ columnType: "boolean", default: false })
   allow_backorder: boolean = false
 
-  @OneToMany(() => ExchangeItem, (item) => item.exchange, {
+  @OneToMany(() => OrderExchangeItem, (item) => item.exchange, {
     cascade: [Cascade.PERSIST],
   })
-  additional_items = new Collection<Rel<ExchangeItem>>(this)
+  additional_items = new Collection<Rel<OrderExchangeItem>>(this)
 
   @OneToMany(
     () => OrderShippingMethod,

packages/modules/order/src/models/index.ts

@@ -1,9 +1,9 @@
 export { default as Address } from "./address"
 export { default as OrderClaim } from "./claim"
-export { default as ClaimItem } from "./claim-item"
+export { default as OrderClaimItem } from "./claim-item"
-export { default as ClaimItemImage } from "./claim-item-image"
+export { default as OrderClaimItemImage } from "./claim-item-image"
 export { default as OrderExchange } from "./exchange"
-export { default as ExchangeItem } from "./exchange-item"
+export { default as OrderExchangeItem } from "./exchange-item"
 export { default as LineItem } from "./line-item"
 export { default as LineItemAdjustment } from "./line-item-adjustment"
 export { default as LineItemTaxLine } from "./line-item-tax-line"

packages/modules/order/src/services/actions/create-claim.ts

@@ -12,7 +12,7 @@ import {
   isString,
   promiseAll,
 } from "@medusajs/utils"
-import { ClaimItem, OrderClaim, Return, ReturnItem } from "@models"
+import { OrderClaim, OrderClaimItem, Return, ReturnItem } from "@models"
 
 function createClaimAndReturnEntities(em, data, order) {
   const claimReference = em.create(OrderClaim, {
@@ -89,7 +89,7 @@ function createClaimAndReturnItems(
         : undefined
     )
 
-    return em.create(ClaimItem, {
+    return em.create(OrderClaimItem, {
       item_id: item.id,
       reason: item.reason,
       quantity: item.quantity,
@@ -111,8 +111,8 @@ async function processAdditionalItems(
   sharedContext
 ) {
   const itemsToAdd: any[] = []
-  const additionalNewItems: ClaimItem[] = []
+  const additionalNewItems: OrderClaimItem[] = []
-  const additionalItems: ClaimItem[] = []
+  const additionalItems: OrderClaimItem[] = []
   data.additional_items?.forEach((item) => {
     const hasItem = item.id
       ? order.items.find((o) => o.item.id === item.id)
@@ -134,7 +134,7 @@ async function processAdditionalItems(
       })
 
       additionalItems.push(
-        em.create(ClaimItem, {
+        em.create(OrderClaimItem, {
           item_id: item.id,
           quantity: item.quantity,
           note: item.note,
@@ -146,7 +146,7 @@ async function processAdditionalItems(
       itemsToAdd.push(item)
 
       additionalNewItems.push(
-        em.create(ClaimItem, {
+        em.create(OrderClaimItem, {
           quantity: item.quantity,
           note: item.note,
           metadata: item.metadata,

packages/modules/order/src/services/actions/create-exchange.ts

@@ -11,7 +11,7 @@ import {
   isString,
   promiseAll,
 } from "@medusajs/utils"
-import { ExchangeItem, OrderExchange, Return, ReturnItem } from "@models"
+import { OrderExchange, OrderExchangeItem, Return, ReturnItem } from "@models"
 
 function createExchangeAndReturnEntities(em, data, order) {
   const exchangeReference = em.create(OrderExchange, {
@@ -77,8 +77,8 @@ async function processAdditionalItems(
   sharedContext
 ) {
   const itemsToAdd: any[] = []
-  const additionalNewItems: ExchangeItem[] = []
+  const additionalNewItems: OrderExchangeItem[] = []
-  const additionalItems: ExchangeItem[] = []
+  const additionalItems: OrderExchangeItem[] = []
   data.additional_items?.forEach((item) => {
     const hasItem = item.id
       ? order.items.find((o) => o.item.id === item.id)
@@ -100,7 +100,7 @@ async function processAdditionalItems(
       })
 
       additionalItems.push(
-        em.create(ExchangeItem, {
+        em.create(OrderExchangeItem, {
           item_id: item.id,
           quantity: item.quantity,
           note: item.note,
@@ -112,7 +112,7 @@ async function processAdditionalItems(
       itemsToAdd.push(item)
 
       additionalNewItems.push(
-        em.create(ExchangeItem, {
+        em.create(OrderExchangeItem, {
           quantity: item.quantity,
           note: item.note,
           metadata: item.metadata,

packages/modules/order/src/services/order-module-service.ts

@@ -41,7 +41,10 @@ import {
   OrderChange,
   OrderChangeAction,
   OrderClaim,
+  OrderClaimItem,
+  OrderClaimItemImage,
   OrderExchange,
+  OrderExchangeItem,
   OrderItem,
   OrderShippingMethod,
   OrderSummary,
@@ -116,7 +119,10 @@ const generateMethodForModels = {
   Return,
   ReturnItem,
   OrderClaim,
+  OrderClaimItem,
+  OrderClaimItemImage,
   OrderExchange,
+  OrderExchangeItem,
 }
 
 // TODO: rm template args here, keep it for later to not collide with carlos work at least as little as possible
@@ -139,7 +145,10 @@ export default class OrderModuleService<
     TReturn extends Return = Return,
     TReturnItem extends ReturnItem = ReturnItem,
     TClaim extends OrderClaim = OrderClaim,
-    TExchange extends OrderExchange = OrderExchange
+    TClaimItem extends OrderClaimItem = OrderClaimItem,
+    TClaimItemImage extends OrderClaimItemImage = OrderClaimItemImage,
+    TExchange extends OrderExchange = OrderExchange,
+    TExchangeItem extends OrderExchangeItem = OrderExchangeItem
   >
   extends ModulesSdkUtils.MedusaService<{
     Order: { dto: OrderTypes.OrderDTO }
@@ -159,10 +168,13 @@ export default class OrderModuleService<
     ReturnReason: { dto: OrderTypes.OrderReturnReasonDTO }
     OrderSummary: { dto: OrderTypes.OrderSummaryDTO }
     Transaction: { dto: OrderTypes.OrderTransactionDTO }
-    Return: { dto: any } // TODO: Add return dto
+    Return: { dto: OrderTypes.ReturnDTO }
-    ReturnItem: { dto: any } // TODO: Add return item dto
+    ReturnItem: { dto: OrderTypes.OrderReturnItemDTO }
-    OrderClaim: { dto: any } // TODO: Add claim dto
+    OrderClaim: { dto: OrderTypes.OrderClaimDTO }
-    OrderExchange: { dto: any } // TODO: Add exchange dto
+    OrderClaimItem: { dto: OrderTypes.OrderClaimItemDTO }
+    OrderClaimItemImage: { dto: OrderTypes.OrderClaimItemImageDTO }
+    OrderExchange: { dto: OrderTypes.OrderExchangeDTO }
+    OrderExchangeItem: { dto: OrderTypes.OrderExchangeItemDTO }
   }>(generateMethodForModels)
   implements IOrderModuleService
 {
@@ -185,7 +197,10 @@ export default class OrderModuleService<
   protected returnService_: ModulesSdkTypes.IMedusaInternalService<TReturn>
   protected returnItemService_: ModulesSdkTypes.IMedusaInternalService<TReturnItem>
   protected orderClaimService_: ModulesSdkTypes.IMedusaInternalService<TClaim>
+  protected orderClaimItemService_: ModulesSdkTypes.IMedusaInternalService<TClaimItem>
+  protected orderClaimItemImageService_: ModulesSdkTypes.IMedusaInternalService<TClaimItemImage>
   protected orderExchangeService_: ModulesSdkTypes.IMedusaInternalService<TExchange>
+  protected orderExchangeItemService_: ModulesSdkTypes.IMedusaInternalService<TExchangeItem>
 
   constructor(
     {