Merge branch 'develop' into fix/todo-use-product-variant-method-to-ge…

…t-sc-availability

.changeset/hip-otters-thank.md

@@ -0,0 +1,5 @@
+---
+"@medusajs/medusa": minor
+---
+
+Add inventory management to create-fulfillment flow

integration-tests/plugins/__tests__/inventory/order/order.js

@@ -0,0 +1,266 @@
+const path = require("path")
+
+const { bootstrapApp } = require("../../../../helpers/bootstrap-app")
+const { initDb, useDb } = require("../../../../helpers/use-db")
+const { setPort, useApi } = require("../../../../helpers/use-api")
+
+const adminSeeder = require("../../../helpers/admin-seeder")
+const cartSeeder = require("../../../helpers/cart-seeder")
+const { simpleProductFactory } = require("../../../../api/factories")
+const { simpleSalesChannelFactory } = require("../../../../api/factories")
+const {
+  simpleOrderFactory,
+  simpleRegionFactory,
+} = require("../../../factories")
+
+jest.setTimeout(30000)
+
+const adminHeaders = { headers: { Authorization: "Bearer test_token" } }
+
+describe("/store/carts", () => {
+  let express
+  let appContainer
+  let dbConnection
+
+  const doAfterEach = async () => {
+    const db = useDb()
+    return await db.teardown()
+  }
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", "..", ".."))
+    dbConnection = await initDb({ cwd })
+    const { container, app, port } = await bootstrapApp({ cwd })
+    appContainer = container
+
+    setPort(port)
+    express = app.listen(port, (err) => {
+      process.send(port)
+    })
+  })
+
+  afterAll(async () => {
+    const db = useDb()
+    await db.shutdown()
+    express.close()
+  })
+
+  afterEach(async () => {
+    jest.clearAllMocks()
+    const db = useDb()
+    return await db.teardown()
+  })
+
+  describe("POST /store/carts/:id", () => {
+    let order
+    let locationId
+    let invItemId
+    let variantId
+    let prodVarInventoryService
+
+    beforeEach(async () => {
+      const api = useApi()
+
+      prodVarInventoryService = appContainer.resolve(
+        "productVariantInventoryService"
+      )
+      const inventoryService = appContainer.resolve("inventoryService")
+      const stockLocationService = appContainer.resolve("stockLocationService")
+      const salesChannelLocationService = appContainer.resolve(
+        "salesChannelLocationService"
+      )
+
+      const r = await simpleRegionFactory(dbConnection, {})
+      await simpleSalesChannelFactory(dbConnection, {
+        id: "test-channel",
+        is_default: true,
+      })
+
+      await adminSeeder(dbConnection)
+
+      const product = await simpleProductFactory(dbConnection, {
+        id: "product1",
+        sales_channels: [{ id: "test-channel" }],
+      })
+      variantId = product.variants[0].id
+
+      const sl = await stockLocationService.create({ name: "test-location" })
+
+      locationId = sl.id
+
+      await salesChannelLocationService.associateLocation(
+        "test-channel",
+        locationId
+      )
+
+      const invItem = await inventoryService.createInventoryItem({
+        sku: "test-sku",
+      })
+      invItemId = invItem.id
+
+      await prodVarInventoryService.attachInventoryItem(variantId, invItem.id)
+
+      await inventoryService.createInventoryLevel({
+        inventory_item_id: invItem.id,
+        location_id: locationId,
+        stocked_quantity: 1,
+      })
+
+      const { id: orderId } = await simpleOrderFactory(dbConnection, {
+        sales_channel: "test-channel",
+        line_items: [
+          {
+            variant_id: variantId,
+            quantity: 2,
+            id: "line-item-id",
+          },
+        ],
+        shipping_methods: [
+          {
+            shipping_option: {
+              region_id: r.id,
+            },
+          },
+        ],
+      })
+
+      const orderRes = await api.get(`/admin/orders/${orderId}`, adminHeaders)
+      order = orderRes.data.order
+
+      const inventoryItem = await api.get(
+        `/admin/inventory-items/${invItem.id}`,
+        adminHeaders
+      )
+
+      expect(inventoryItem.data.inventory_item.location_levels[0]).toEqual(
+        expect.objectContaining({
+          stocked_quantity: 1,
+          reserved_quantity: 0,
+          available_quantity: 1,
+        })
+      )
+    })
+
+    describe("Fulfillments", () => {
+      const lineItemId = "line-item-id"
+      it("Adjusts reservations on successful fulfillment with reservation", async () => {
+        const api = useApi()
+
+        await prodVarInventoryService.reserveQuantity(variantId, 1, {
+          locationId: locationId,
+          lineItemId: order.items[0].id,
+        })
+
+        let inventoryItem = await api.get(
+          `/admin/inventory-items/${invItemId}`,
+          adminHeaders
+        )
+
+        expect(inventoryItem.data.inventory_item.location_levels[0]).toEqual(
+          expect.objectContaining({
+            stocked_quantity: 1,
+            reserved_quantity: 1,
+            available_quantity: 0,
+          })
+        )
+
+        const fulfillmentRes = await api.post(
+          `/admin/orders/${order.id}/fulfillment`,
+          {
+            items: [{ item_id: lineItemId, quantity: 1 }],
+            location_id: locationId,
+          },
+          adminHeaders
+        )
+
+        expect(fulfillmentRes.status).toBe(200)
+        expect(fulfillmentRes.data.order.fulfillment_status).toBe(
+          "partially_fulfilled"
+        )
+
+        inventoryItem = await api.get(
+          `/admin/inventory-items/${invItemId}`,
+          adminHeaders
+        )
+
+        const reservations = await api.get(
+          `/admin/reservations?inventory_item_id[]=${invItemId}`,
+          adminHeaders
+        )
+
+        expect(reservations.data.reservations.length).toBe(0)
+        expect(inventoryItem.data.inventory_item.location_levels[0]).toEqual(
+          expect.objectContaining({
+            stocked_quantity: 0,
+            reserved_quantity: 0,
+            available_quantity: 0,
+          })
+        )
+      })
+
+      it("adjusts inventory levels on successful fulfillment without reservation", async () => {
+        const api = useApi()
+
+        const fulfillmentRes = await api.post(
+          `/admin/orders/${order.id}/fulfillment`,
+          {
+            items: [{ item_id: lineItemId, quantity: 1 }],
+            location_id: locationId,
+          },
+          adminHeaders
+        )
+        expect(fulfillmentRes.status).toBe(200)
+        expect(fulfillmentRes.data.order.fulfillment_status).toBe(
+          "partially_fulfilled"
+        )
+
+        const inventoryItem = await api.get(
+          `/admin/inventory-items/${invItemId}`,
+          adminHeaders
+        )
+
+        expect(inventoryItem.data.inventory_item.location_levels[0]).toEqual(
+          expect.objectContaining({
+            stocked_quantity: 0,
+            reserved_quantity: 0,
+            available_quantity: 0,
+          })
+        )
+      })
+
+      it("Fails to create fulfillment if there is not enough inventory at the fulfillment location", async () => {
+        const api = useApi()
+
+        const err = await api
+          .post(
+            `/admin/orders/${order.id}/fulfillment`,
+            {
+              items: [{ item_id: lineItemId, quantity: 2 }],
+              location_id: locationId,
+            },
+            adminHeaders
+          )
+          .catch((e) => e)
+
+        expect(err.response.status).toBe(400)
+        expect(err.response.data).toEqual({
+          type: "not_allowed",
+          message: `Insufficient stock for item: ${order.items[0].title}`,
+        })
+
+        const inventoryItem = await api.get(
+          `/admin/inventory-items/${invItemId}`,
+          adminHeaders
+        )
+
+        expect(inventoryItem.data.inventory_item.location_levels[0]).toEqual(
+          expect.objectContaining({
+            stocked_quantity: 1,
+            reserved_quantity: 0,
+            available_quantity: 1,
+          })
+        )
+      })
+    })
+  })
+})

integration-tests/plugins/factories/simple-order-factory.ts

@@ -5,6 +5,9 @@ import {
   Order,
   PaymentStatus,
   FulfillmentStatus,
+  SalesChannel,
+  Discount,
+  isString,
 } from "@medusajs/medusa"
 
 import {
@@ -24,6 +27,11 @@ import {
   ShippingMethodFactoryData,
   simpleShippingMethodFactory,
 } from "./simple-shipping-method-factory"
+import {
+  SalesChannelFactoryData,
+  simpleSalesChannelFactory,
+} from "../../api/factories"
+import { isDefined } from "medusa-core-utils"
 
 export type OrderFactoryData = {
   id?: string
@@ -33,6 +41,7 @@ export type OrderFactoryData = {
   email?: string | null
   currency_code?: string
   tax_rate?: number | null
+  sales_channel?: string | SalesChannelFactoryData
   line_items?: LineItemFactoryData[]
   discounts?: DiscountFactoryData[]
   shipping_address?: AddressFactoryData
@@ -72,15 +81,14 @@ export const simpleOrderFactory = async (
   })
   const customer = await manager.save(customerToSave)
 
-  let discounts = []
+  let discounts: Discount[] = []
   if (typeof data.discounts !== "undefined") {
     discounts = await Promise.all(
       data.discounts.map((d) => simpleDiscountFactory(connection, d, seed))
     )
   }
-
   const id = data.id || `simple-order-${Math.random() * 1000}`
-  const toSave = manager.create(Order, {
+  const toCreate: Partial<Order> = {
     id,
     discounts,
     payment_status: data.payment_status ?? PaymentStatus.AWAITING,
@@ -92,16 +100,44 @@ export const simpleOrderFactory = async (
     currency_code: currencyCode,
     tax_rate: taxRate,
     shipping_address_id: address.id,
-  })
+  }
+
+  let sc_id
+  if (isDefined(data.sales_channel)) {
+    let sc
+
+    if (isString(data.sales_channel)) {
+      sc = await manager.findOne(SalesChannel, {
+        where: { id: data.sales_channel },
+      })
+    }
+
+    if (!sc) {
+      sc = await simpleSalesChannelFactory(
+        connection,
+        isString(data.sales_channel)
+          ? { id: data.sales_channel }
+          : data.sales_channel
+      )
+    }
+
+    sc_id = sc.id
+  }
+
+  if (sc_id) {
+    toCreate.sales_channel_id = sc_id
+  }
+
+  const toSave = manager.create(Order, toCreate)
 
-  const order = await manager.save(toSave)
+  const order = await manager.save(Order, toSave)
 
   const shippingMethods = data.shipping_methods || []
   for (const sm of shippingMethods) {
     await simpleShippingMethodFactory(connection, { ...sm, order_id: order.id })
   }
 
-  const items = data.line_items
+  const items = data.line_items || []
   for (const item of items) {
     await simpleLineItemFactory(connection, { ...item, order_id: id })
   }

packages/medusa/src/api/routes/admin/index.js

@@ -27,6 +27,7 @@ import regionRoutes from "./regions"
 import reservationRoutes from "./reservations"
 import returnReasonRoutes from "./return-reasons"
 import returnRoutes from "./returns"
+import reservationRoutes from "./reservations"
 import salesChannelRoutes from "./sales-channels"
 import shippingOptionRoutes from "./shipping-options"
 import shippingProfileRoutes from "./shipping-profiles"
@@ -101,6 +102,7 @@ export default (app, container, config) => {
   reservationRoutes(route)
   returnReasonRoutes(route)
   returnRoutes(route)
+  reservationRoutes(route)
   salesChannelRoutes(route)
   shippingOptionRoutes(route, featureFlagRouter)
   shippingProfileRoutes(route)