feat(order): cancel fulfillment (#7573)

2024-06-02 09:33:24 -03:00
parent 4e04214612
commit af0140d317
30 changed files with 745 additions and 298 deletions
@@ -418,208 +418,6 @@ moduleIntegrationTestRunner({
        )
        expect(orders4.length).toEqual(0)
      })
-
-      it("should create an order, fulfill, ship and return the items", async function () {
-        const createdOrder = await service.create(input)
-
-        // Fullfilment
-        await service.registerFulfillment({
-          order_id: createdOrder.id,
-          items: createdOrder.items!.map((item) => {
-            return {
-              id: item.id,
-              quantity: item.quantity,
-            }
-          }),
-        })
-
-        let getOrder = await service.retrieve(createdOrder.id, {
-          select: [
-            "id",
-            "version",
-            "items.id",
-            "items.quantity",
-            "items.detail.id",
-            "items.detail.version",
-            "items.detail.quantity",
-            "items.detail.shipped_quantity",
-            "items.detail.fulfilled_quantity",
-          ],
-          relations: ["items", "items.detail"],
-        })
-
-        let serializedOrder = JSON.parse(JSON.stringify(getOrder))
-
-        expect(serializedOrder).toEqual(
-          expect.objectContaining({
-            version: 2,
-            items: [
-              expect.objectContaining({
-                quantity: 1,
-                detail: expect.objectContaining({
-                  version: 2,
-                  quantity: 1,
-                  fulfilled_quantity: 1,
-                  shipped_quantity: 0,
-                }),
-              }),
-              expect.objectContaining({
-                quantity: 2,
-                detail: expect.objectContaining({
-                  version: 2,
-                  quantity: 2,
-                  fulfilled_quantity: 2,
-                  shipped_quantity: 0,
-                }),
-              }),
-              expect.objectContaining({
-                quantity: 1,
-                detail: expect.objectContaining({
-                  version: 2,
-                  quantity: 1,
-                  fulfilled_quantity: 1,
-                  shipped_quantity: 0,
-                }),
-              }),
-            ],
-          })
-        )
-
-        // Shipment
-        await service.registerShipment({
-          order_id: createdOrder.id,
-          reference: Modules.FULFILLMENT,
-          items: createdOrder.items!.map((item) => {
-            return {
-              id: item.id,
-              quantity: item.quantity,
-            }
-          }),
-        })
-
-        getOrder = await service.retrieve(createdOrder.id, {
-          select: [
-            "id",
-            "version",
-            "items.id",
-            "items.quantity",
-            "items.detail.id",
-            "items.detail.version",
-            "items.detail.quantity",
-            "items.detail.shipped_quantity",
-            "items.detail.fulfilled_quantity",
-          ],
-          relations: ["items", "items.detail"],
-        })
-
-        serializedOrder = JSON.parse(JSON.stringify(getOrder))
-
-        expect(serializedOrder).toEqual(
-          expect.objectContaining({
-            version: 3,
-            items: [
-              expect.objectContaining({
-                quantity: 1,
-                detail: expect.objectContaining({
-                  version: 3,
-                  quantity: 1,
-                  fulfilled_quantity: 1,
-                  shipped_quantity: 1,
-                }),
-              }),
-              expect.objectContaining({
-                quantity: 2,
-                detail: expect.objectContaining({
-                  version: 3,
-                  quantity: 2,
-                  fulfilled_quantity: 2,
-                  shipped_quantity: 2,
-                }),
-              }),
-              expect.objectContaining({
-                quantity: 1,
-                detail: expect.objectContaining({
-                  version: 3,
-                  quantity: 1,
-                  fulfilled_quantity: 1,
-                  shipped_quantity: 1,
-                }),
-              }),
-            ],
-          })
-        )
-
-        // Return
-        await service.createReturn({
-          order_id: createdOrder.id,
-          reference: Modules.FULFILLMENT,
-          description: "Return all the items",
-          internal_note: "user wants to return all items",
-          shipping_method: createdOrder.shipping_methods![0].id,
-          items: createdOrder.items!.map((item) => {
-            return {
-              id: item.id,
-              quantity: item.quantity,
-            }
-          }),
-        })
-
-        getOrder = await service.retrieve(createdOrder.id, {
-          select: [
-            "id",
-            "version",
-            "items.id",
-            "items.quantity",
-            "items.detail.id",
-            "items.detail.version",
-            "items.detail.quantity",
-            "items.detail.shipped_quantity",
-            "items.detail.fulfilled_quantity",
-            "items.detail.return_requested_quantity",
-          ],
-          relations: ["items", "items.detail"],
-        })
-
-        serializedOrder = JSON.parse(JSON.stringify(getOrder))
-
-        expect(serializedOrder).toEqual(
-          expect.objectContaining({
-            version: 4,
-            items: [
-              expect.objectContaining({
-                quantity: 1,
-                detail: expect.objectContaining({
-                  version: 4,
-                  quantity: 1,
-                  fulfilled_quantity: 1,
-                  shipped_quantity: 1,
-                  return_requested_quantity: 1,
-                }),
-              }),
-              expect.objectContaining({
-                quantity: 2,
-                detail: expect.objectContaining({
-                  version: 4,
-                  quantity: 2,
-                  fulfilled_quantity: 2,
-                  shipped_quantity: 2,
-                  return_requested_quantity: 2,
-                }),
-              }),
-              expect.objectContaining({
-                quantity: 1,
-                detail: expect.objectContaining({
-                  version: 4,
-                  quantity: 1,
-                  fulfilled_quantity: 1,
-                  shipped_quantity: 1,
-                  return_requested_quantity: 1,
-                }),
-              }),
-            ],
-          })
-        )
-      })
    })
  },
 })
@@ -0,0 +1,308 @@
+import { Modules } from "@medusajs/modules-sdk"
+import { CreateOrderDTO, IOrderModuleService } from "@medusajs/types"
+import { SuiteOptions, moduleIntegrationTestRunner } from "medusa-test-utils"
+
+jest.setTimeout(100000)
+
+moduleIntegrationTestRunner({
+  moduleName: Modules.ORDER,
+  testSuite: ({ service }: SuiteOptions<IOrderModuleService>) => {
+    describe("Order Module Service - Return flows", () => {
+      const input = {
+        email: "foo@bar.com",
+        items: [
+          {
+            title: "Item 1",
+            subtitle: "Subtitle 1",
+            thumbnail: "thumbnail1.jpg",
+            quantity: 1,
+            product_id: "product1",
+            product_title: "Product 1",
+            product_description: "Description 1",
+            product_subtitle: "Product Subtitle 1",
+            product_type: "Type 1",
+            product_collection: "Collection 1",
+            product_handle: "handle1",
+            variant_id: "variant1",
+            variant_sku: "SKU1",
+            variant_barcode: "Barcode1",
+            variant_title: "Variant 1",
+            variant_option_values: {
+              color: "Red",
+              size: "Large",
+            },
+            requires_shipping: true,
+            is_discountable: true,
+            is_tax_inclusive: true,
+            compare_at_unit_price: 10,
+            unit_price: 8,
+            tax_lines: [
+              {
+                description: "Tax 1",
+                tax_rate_id: "tax_usa",
+                code: "code",
+                rate: 0.1,
+                provider_id: "taxify_master",
+              },
+            ],
+            adjustments: [
+              {
+                code: "VIP_10",
+                amount: 10,
+                description: "VIP discount",
+                promotion_id: "prom_123",
+                provider_id: "coupon_kings",
+              },
+            ],
+          },
+          {
+            title: "Item 2",
+            quantity: 2,
+            unit_price: 5,
+          },
+          {
+            title: "Item 3",
+            quantity: 1,
+            unit_price: 30,
+          },
+        ],
+        sales_channel_id: "test",
+        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,
+          },
+        ],
+        transactions: [
+          {
+            amount: 58,
+            currency_code: "USD",
+            reference: "payment",
+            reference_id: "pay_123",
+          },
+        ],
+        currency_code: "usd",
+        customer_id: "joe",
+      } as CreateOrderDTO
+
+      it("should create an order, fulfill, ship and return the items and cancel some item return", async function () {
+        const createdOrder = await service.create(input)
+
+        // Fullfilment
+        await service.registerFulfillment({
+          order_id: createdOrder.id,
+          items: createdOrder.items!.map((item) => {
+            return {
+              id: item.id,
+              quantity: item.quantity,
+            }
+          }),
+        })
+
+        let getOrder = await service.retrieve(createdOrder.id, {
+          select: [
+            "id",
+            "version",
+            "items.id",
+            "items.quantity",
+            "items.detail.id",
+            "items.detail.version",
+            "items.detail.quantity",
+            "items.detail.shipped_quantity",
+            "items.detail.fulfilled_quantity",
+          ],
+          relations: ["items", "items.detail"],
+        })
+
+        let serializedOrder = JSON.parse(JSON.stringify(getOrder))
+
+        expect(serializedOrder).toEqual(
+          expect.objectContaining({
+            version: 2,
+            items: [
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 2,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 0,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 2,
+                detail: expect.objectContaining({
+                  version: 2,
+                  quantity: 2,
+                  fulfilled_quantity: 2,
+                  shipped_quantity: 0,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 2,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 0,
+                }),
+              }),
+            ],
+          })
+        )
+
+        // Shipment
+        await service.registerShipment({
+          order_id: createdOrder.id,
+          reference: Modules.FULFILLMENT,
+          items: createdOrder.items!.map((item) => {
+            return {
+              id: item.id,
+              quantity: item.quantity,
+            }
+          }),
+        })
+
+        getOrder = await service.retrieve(createdOrder.id, {
+          select: [
+            "id",
+            "version",
+            "items.id",
+            "items.quantity",
+            "items.detail.id",
+            "items.detail.version",
+            "items.detail.quantity",
+            "items.detail.shipped_quantity",
+            "items.detail.fulfilled_quantity",
+          ],
+          relations: ["items", "items.detail"],
+        })
+
+        serializedOrder = JSON.parse(JSON.stringify(getOrder))
+
+        expect(serializedOrder).toEqual(
+          expect.objectContaining({
+            version: 3,
+            items: [
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 3,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 1,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 2,
+                detail: expect.objectContaining({
+                  version: 3,
+                  quantity: 2,
+                  fulfilled_quantity: 2,
+                  shipped_quantity: 2,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 3,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 1,
+                }),
+              }),
+            ],
+          })
+        )
+
+        // Return
+        await service.createReturn({
+          order_id: createdOrder.id,
+          reference: Modules.FULFILLMENT,
+          description: "Return all the items",
+          internal_note: "user wants to return all items",
+          shipping_method: createdOrder.shipping_methods![0].id,
+          items: createdOrder.items!.map((item) => {
+            return {
+              id: item.id,
+              quantity: item.quantity,
+            }
+          }),
+        })
+
+        getOrder = await service.retrieve(createdOrder.id, {
+          select: [
+            "id",
+            "version",
+            "items.id",
+            "items.quantity",
+            "items.detail.id",
+            "items.detail.version",
+            "items.detail.quantity",
+            "items.detail.shipped_quantity",
+            "items.detail.fulfilled_quantity",
+            "items.detail.return_requested_quantity",
+          ],
+          relations: ["items", "items.detail"],
+        })
+
+        serializedOrder = JSON.parse(JSON.stringify(getOrder))
+
+        expect(serializedOrder).toEqual(
+          expect.objectContaining({
+            version: 4,
+            items: [
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 4,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 1,
+                  return_requested_quantity: 1,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 2,
+                detail: expect.objectContaining({
+                  version: 4,
+                  quantity: 2,
+                  fulfilled_quantity: 2,
+                  shipped_quantity: 2,
+                  return_requested_quantity: 2,
+                }),
+              }),
+              expect.objectContaining({
+                quantity: 1,
+                detail: expect.objectContaining({
+                  version: 4,
+                  quantity: 1,
+                  fulfilled_quantity: 1,
+                  shipped_quantity: 1,
+                  return_requested_quantity: 1,
+                }),
+              }),
+            ],
+          })
+        )
+      })
+    })
+  },
+})
@@ -95,7 +95,7 @@ describe("Order Return - Actions", function () {
        order: originalOrder,
        actions,
      })
-    }).toThrow(`Reference ID "333" not found.`)
+    }).toThrow(`Item ID "333" not found.`)
  })

  it("should validate return received", function () {
@@ -2142,6 +2142,40 @@ export default class OrderModuleService<
    await this.confirmOrderChange(change[0].id, sharedContext)
  }

+  @InjectTransactionManager("baseRepository_")
+  async cancelFulfillment(
+    data: OrderTypes.CancelOrderFulfillmentDTO,
+    sharedContext?: Context
+  ): Promise<void> {
+    const items = data.items.map((item) => {
+      return {
+        action: ChangeActionType.CANCEL_ITEM_FULFILLMENT,
+        internal_note: item.internal_note,
+        reference: data.reference,
+        reference_id: data.reference_id,
+        details: {
+          reference_id: item.id,
+          quantity: item.quantity,
+          metadata: item.metadata,
+        },
+      }
+    })
+
+    const change = await this.createOrderChange_(
+      {
+        order_id: data.order_id,
+        description: data.description,
+        internal_note: data.internal_note,
+        created_by: data.created_by,
+        metadata: data.metadata,
+        actions: items,
+      },
+      sharedContext
+    )
+
+    await this.confirmOrderChange(change[0].id, sharedContext)
+  }
+
  @InjectTransactionManager("baseRepository_")
  async registerShipment(
    data: OrderTypes.RegisterOrderShipmentDTO,
@@ -2,6 +2,7 @@ export enum ChangeActionType {
  CANCEL = "CANCEL",
  CANCEL_RETURN = "CANCEL_RETURN",
  FULFILL_ITEM = "FULFILL_ITEM",
+  CANCEL_ITEM_FULFILLMENT = "CANCEL_ITEM_FULFILLMENT",
  ITEM_ADD = "ITEM_ADD",
  ITEM_REMOVE = "ITEM_REMOVE",
  RECEIVE_DAMAGED_RETURN_ITEM = "RECEIVE_DAMAGED_RETURN_ITEM",
@@ -0,0 +1,74 @@
+import { MathBN, MedusaError, isDefined } from "@medusajs/utils"
+import { ChangeActionType } from "../action-key"
+import { OrderChangeProcessing } from "../calculate-order-change"
+
+OrderChangeProcessing.registerActionType(
+  ChangeActionType.CANCEL_ITEM_FULFILLMENT,
+  {
+    operation({ action, currentOrder }) {
+      const existing = currentOrder.items.find(
+        (item) => item.id === action.details.reference_id
+      )!
+
+      existing.detail.fulfilled_quantity ??= 0
+
+      existing.detail.fulfilled_quantity = MathBN.sub(
+        existing.detail.fulfilled_quantity,
+        action.details.quantity
+      )
+    },
+    revert({ action, currentOrder }) {
+      const existing = currentOrder.items.find(
+        (item) => item.id === action.reference_id
+      )!
+
+      existing.detail.fulfilled_quantity = MathBN.add(
+        existing.detail.fulfilled_quantity,
+        action.details.quantity
+      )
+    },
+    validate({ action, currentOrder }) {
+      const refId = action.details?.reference_id
+      if (!isDefined(refId)) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          "Reference ID is required."
+        )
+      }
+
+      const existing = currentOrder.items.find((item) => item.id === refId)
+
+      if (!existing) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Item ID "${refId}" not found.`
+        )
+      }
+
+      if (!action.details?.quantity) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Quantity to cancel item fulfillment ${refId} is required.`
+        )
+      }
+
+      if (action.details?.quantity < 1) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Quantity to cancel item ${refId} must be greater than 0.`
+        )
+      }
+
+      const greater = MathBN.gt(
+        action.details?.quantity,
+        existing.detail?.fulfilled_quantity
+      )
+      if (greater) {
+        throw new MedusaError(
+          MedusaError.Types.INVALID_DATA,
+          `Cannot cancel more items than what was fulfilled for item ${refId}.`
+        )
+      }
+    },
+  }
+)
@@ -48,7 +48,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.CANCEL_RETURN, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }

@@ -38,7 +38,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.FULFILL_ITEM, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }

@@ -1,4 +1,5 @@
 export * from "./cancel"
+export * from "./cancel-item-fulfillment"
 export * from "./cancel-return"
 export * from "./fulfill-item"
 export * from "./item-add"
@@ -58,7 +58,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.ITEM_REMOVE, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }

@@ -89,7 +89,7 @@ OrderChangeProcessing.registerActionType(
      if (!existing) {
        throw new MedusaError(
          MedusaError.Types.INVALID_DATA,
-          `Reference ID "${refId}" not found.`
+          `Item ID "${refId}" not found.`
        )
      }

@@ -95,7 +95,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.RECEIVE_RETURN_ITEM, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }

@@ -42,7 +42,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.RETURN_ITEM, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }

@@ -38,7 +38,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.SHIP_ITEM, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }

@@ -38,7 +38,7 @@ OrderChangeProcessing.registerActionType(ChangeActionType.WRITE_OFF_ITEM, {
    if (!existing) {
      throw new MedusaError(
        MedusaError.Types.INVALID_DATA,
-        `Reference ID "${refId}" not found.`
+        `Item ID "${refId}" not found.`
      )
    }