chores(medusa): Improve draft order creation perf flow (#3431)

.changeset/many-wolves-sit.md

@@ -0,0 +1,5 @@
+---
+"@medusajs/medusa": patch
+---
+
+chores(medusa): Improve draft order creation perf flow

packages/medusa/src/services/__tests__/custom-shipping-option.js

@@ -1,5 +1,6 @@
 import CustomShippingOptionService from "../custom-shipping-option"
-import { MockManager, MockRepository, IdMap } from "medusa-test-utils"
+
+import { MockManager, MockRepository } from "medusa-test-utils"
 
 describe("CustomShippingOptionService", () => {
   describe("list", () => {
@@ -108,20 +109,22 @@ describe("CustomShippingOptionService", () => {
       await customShippingOptionService.create(customShippingOption)
 
       expect(customShippingOptionRepository.create).toHaveBeenCalledTimes(1)
-      expect(customShippingOptionRepository.create).toHaveBeenCalledWith({
+      expect(customShippingOptionRepository.create).toHaveBeenCalledWith([
+        {
           cart_id: "test-cso-cart",
           shipping_option_id: "test-so",
           price: 30,
-        metadata: undefined,
+        },
-      })
+      ])
 
       expect(customShippingOptionRepository.save).toHaveBeenCalledTimes(1)
       expect(customShippingOptionRepository.save).toHaveBeenCalledWith({
-        id: "test-cso",
+        0: {
           cart_id: "test-cso-cart",
           shipping_option_id: "test-so",
           price: 30,
-        metadata: undefined,
+        },
+        id: "test-cso",
       })
     })
   })

packages/medusa/src/services/__tests__/draft-order.js

@@ -35,10 +35,12 @@ describe("DraftOrderService", () => {
 
     const lineItemService = {
       generate: jest.fn().mockImplementation(() =>
-        Promise.resolve({
+        Promise.resolve([
+          {
             title: "test-item",
             variant_id: "test-variant",
-        })
+          },
+        ])
       ),
       create: jest.fn().mockImplementation((data) => data),
       withTransaction: function () {
@@ -88,6 +90,12 @@ describe("DraftOrderService", () => {
           ...testOrder,
         })
       ),
+      retrieveWithTotals: jest.fn().mockReturnValue(
+        Promise.resolve({
+          id: "test-cart",
+          ...testOrder,
+        })
+      ),
       update: jest.fn(),
       applyDiscount: jest.fn(),
       addShippingMethod: jest.fn(),
@@ -151,28 +159,37 @@ describe("DraftOrderService", () => {
 
       expect(cartService.addShippingMethod).toHaveBeenCalledTimes(1)
       expect(cartService.addShippingMethod).toHaveBeenCalledWith(
-        "test-cart",
+        {
+          id: "test-cart",
+          ...testOrder,
+        },
         "test-option",
         {}
       )
 
       expect(lineItemService.generate).toHaveBeenCalledTimes(1)
       expect(lineItemService.generate).toHaveBeenCalledWith(
-        "test-variant",
+        [
-        "test-region",
-        2,
           {
+            variantId: "test-variant",
+            quantity: 2,
             metadata: {},
             unit_price: undefined,
+          },
+        ],
+        {
+          region_id: "test-region",
         }
       )
 
       expect(lineItemService.create).toHaveBeenCalledTimes(1)
-      expect(lineItemService.create).toHaveBeenCalledWith({
+      expect(lineItemService.create).toHaveBeenCalledWith([
+        {
           cart_id: cartId,
           title,
           variant_id: "test-variant",
-      })
+        },
+      ])
 
       expect(cartService.applyDiscount).toHaveBeenCalledTimes(0)
     })
@@ -181,6 +198,8 @@ describe("DraftOrderService", () => {
       const cartId = "test-cart"
       const title = "test-item"
 
+      const originalTestOrder = { ...testOrder }
+
       testOrder["discounts"] = [{ code: "TEST" }]
       await draftOrderService.create(testOrder)
 
@@ -200,28 +219,37 @@ describe("DraftOrderService", () => {
 
       expect(cartService.addShippingMethod).toHaveBeenCalledTimes(1)
       expect(cartService.addShippingMethod).toHaveBeenCalledWith(
-        "test-cart",
+        {
+          id: "test-cart",
+          ...originalTestOrder,
+        },
         "test-option",
         {}
       )
 
       expect(lineItemService.generate).toHaveBeenCalledTimes(1)
       expect(lineItemService.generate).toHaveBeenCalledWith(
-        "test-variant",
+        [
-        "test-region",
-        2,
           {
+            variantId: "test-variant",
+            quantity: 2,
             metadata: {},
             unit_price: undefined,
+          },
+        ],
+        {
+          region_id: "test-region",
         }
       )
 
       expect(lineItemService.create).toHaveBeenCalledTimes(1)
-      expect(lineItemService.create).toHaveBeenCalledWith({
+      expect(lineItemService.create).toHaveBeenCalledWith([
+        {
           cart_id: cartId,
           title,
           variant_id: "test-variant",
-      })
+        },
+      ])
 
       expect(cartService.update).toHaveBeenCalledTimes(1)
       expect(cartService.update).toHaveBeenCalledWith(cartId, {

packages/medusa/src/services/cart.ts

@@ -36,7 +36,7 @@ import {
   TotalField,
   WithRequiredProperty,
 } from "../types/common"
-import { buildQuery, setMetadata } from "../utils"
+import { buildQuery, isString, setMetadata } from "../utils"
 import { FlagRouter } from "../utils/flag-router"
 import { validateEmail } from "../utils/is-email"
 import { PaymentSessionInput } from "../types/payment"
@@ -2060,25 +2060,28 @@ class CartService extends TransactionBaseService {
    * Shipping Option is a possible way to ship an order. Shipping Methods may
    * also have additional details in the data field such as an id for a package
    * shop.
-   * @param cartId - the id of the cart to add shipping method to
+   * @param cartOrId - the id or the cart to add shipping method to
    * @param optionId - id of shipping option to add as valid method
    * @param data - the fulmillment data for the method
    * @return the result of the update operation
    */
   async addShippingMethod(
-    cartId: string,
+    cartOrId: string | Cart,
     optionId: string,
     data: Record<string, unknown> = {}
   ): Promise<Cart> {
     return await this.atomicPhase_(
       async (transactionManager: EntityManager) => {
-        const cart = await this.retrieveWithTotals(cartId, {
+        const cart = !isString(cartOrId)
+          ? cartOrId
+          : await this.retrieveWithTotals(cartOrId, {
               relations: [
                 "shipping_methods",
                 "shipping_methods.shipping_option",
                 "items",
                 "items.variant",
                 "items.variant.product",
+                "payment_sessions",
               ],
             })
 
@@ -2140,7 +2143,7 @@ class CartService extends TransactionBaseService {
           )
         }
 
-        const updatedCart = await this.retrieve(cartId, {
+        const updatedCart = await this.retrieve(cart.id, {
           relations: ["discounts", "discounts.rule", "shipping_methods"],
         })
 

packages/medusa/src/services/custom-shipping-option.ts

@@ -1,5 +1,5 @@
 import { MedusaError } from "medusa-core-utils"
-import { EntityManager } from "typeorm"
+import { DeepPartial, EntityManager } from "typeorm"
 import { TransactionBaseService } from "../interfaces"
 import { CustomShippingOption } from "../models"
 import { CustomShippingOptionRepository } from "../repositories/custom-shipping-option"
@@ -86,23 +86,28 @@ class CustomShippingOptionService extends TransactionBaseService {
    * @param config - any configurations if needed, including meta data
    * @return resolves to the creation result
    */
-  async create(
+  async create<
-    data: CreateCustomShippingOptionInput
+    T = CreateCustomShippingOptionInput | CreateCustomShippingOptionInput[],
-  ): Promise<CustomShippingOption> {
+    TResult = T extends CreateCustomShippingOptionInput[]
-    const { cart_id, shipping_option_id, price, metadata } = data
+      ? CustomShippingOption[]
-
+      : CustomShippingOption
-    const manager = this.manager_
+  >(data: T): Promise<TResult> {
+    const manager = this.transactionManager_ ?? this.manager_
     const customShippingOptionRepo = manager.getCustomRepository(
       this.customShippingOptionRepository_
     )
+    const data_ = (
+      Array.isArray(data) ? data : [data]
+    ) as DeepPartial<CustomShippingOption>[]
 
-    const customShippingOption = customShippingOptionRepo.create({
+    const customShippingOptions = customShippingOptionRepo.create(data_)
-      cart_id,
+    const shippingOptions = await customShippingOptionRepo.save(
-      shipping_option_id,
+      customShippingOptions
-      price,
+    )
-      metadata,
+
-    })
+    return (Array.isArray(data)
-    return await customShippingOptionRepo.save(customShippingOption)
+      ? shippingOptions
+      : shippingOptions[0]) as unknown as TResult
   }
 }
 

packages/medusa/src/services/draft-order.ts

@@ -1,7 +1,13 @@
 import { isDefined, MedusaError } from "medusa-core-utils"
 import { Brackets, EntityManager, FindManyOptions, UpdateResult } from "typeorm"
 import { TransactionBaseService } from "../interfaces"
-import { CartType, DraftOrder, DraftOrderStatus } from "../models"
+import {
+  CartType,
+  DraftOrder,
+  DraftOrderStatus,
+  LineItem,
+  ShippingMethod,
+} from "../models"
 import { DraftOrderRepository } from "../repositories/draft-order"
 import { OrderRepository } from "../repositories/order"
 import { PaymentRepository } from "../repositories/payment"
@@ -14,6 +20,7 @@ import EventBusService from "./event-bus"
 import LineItemService from "./line-item"
 import ProductVariantService from "./product-variant"
 import ShippingOptionService from "./shipping-option"
+import { GenerateInputData } from "../types/line-item"
 
 type InjectedDependencies = {
   manager: EntityManager
@@ -271,7 +278,7 @@ class DraftOrderService extends TransactionBaseService {
         const cartServiceTx =
           this.cartService_.withTransaction(transactionManager)
 
-        const createdCart = await cartServiceTx.create({
+        let createdCart = await cartServiceTx.create({
           type: CartType.DRAFT_ORDER,
           ...rawCart,
         })
@@ -293,32 +300,29 @@ class DraftOrderService extends TransactionBaseService {
         const lineItemServiceTx =
           this.lineItemService_.withTransaction(transactionManager)
 
-        for (const item of items || []) {
+        const itemsToGenerate: GenerateInputData[] = []
-          if (item.variant_id) {
+        const itemsToCreate: Partial<LineItem>[] = []
-            const line = await lineItemServiceTx.generate(
-              item.variant_id,
-              data.region_id,
-              item.quantity,
-              {
-                metadata: item?.metadata || {},
-                unit_price: item.unit_price,
-              }
-            )
 
-            await lineItemServiceTx.create({
+        // prepare that for next steps
-              ...line,
+        ;(items ?? []).forEach((item) => {
-              cart_id: createdCart.id,
+          if (item.variant_id) {
+            itemsToGenerate.push({
+              variantId: item.variant_id,
+              quantity: item.quantity,
+              metadata: item.metadata,
+              unit_price: item.unit_price,
             })
-          } else {
+            return
+          }
+
           let price
-            if (typeof item.unit_price === `undefined` || item.unit_price < 0) {
+          if (!isDefined(item.unit_price) || item.unit_price < 0) {
             price = 0
           } else {
             price = item.unit_price
           }
 
-            // custom line items can be added to a draft order
+          itemsToCreate.push({
-            await lineItemServiceTx.create({
             cart_id: createdCart.id,
             has_shipping: true,
             title: item.title || "Custom item",
@@ -326,29 +330,76 @@ class DraftOrderService extends TransactionBaseService {
             unit_price: price,
             quantity: item.quantity,
           })
+        })
+
+        const promises: Promise<any>[] = []
+
+        // generate line item link to a variant
+        if (itemsToGenerate.length) {
+          const generatedLines = await lineItemServiceTx.generate(
+            itemsToGenerate,
+            {
+              region_id: data.region_id,
             }
+          )
+
+          const toCreate = generatedLines.map((line) => ({
+            ...line,
+            cart_id: createdCart.id,
+          }))
+
+          promises.push(lineItemServiceTx.create(toCreate))
         }
 
-        if (discounts?.length) {
+        // custom line items can be added to a draft order
-          await cartServiceTx.update(createdCart.id, { discounts })
+        if (itemsToCreate.length) {
+          promises.push(lineItemServiceTx.create(itemsToCreate))
         }
 
-        for (const method of shipping_methods) {
+        const shippingMethodToCreate: Partial<ShippingMethod>[] = []
-          if (typeof method.price !== "undefined") {
+
-            await this.customShippingOptionService_
+        shipping_methods.forEach((method) => {
-              .withTransaction(transactionManager)
+          if (isDefined(method.price)) {
-              .create({
+            shippingMethodToCreate.push({
               shipping_option_id: method.option_id,
               cart_id: createdCart.id,
               price: method.price,
             })
+            return
+          }
+        })
+
+        if (shippingMethodToCreate.length) {
+          await this.customShippingOptionService_
+            .withTransaction(transactionManager)
+            .create(shippingMethodToCreate)
         }
 
-          await cartServiceTx.addShippingMethod(
+        createdCart = await cartServiceTx.retrieveWithTotals(createdCart.id, {
-            createdCart.id,
+          relations: [
+            "shipping_methods",
+            "shipping_methods.shipping_option",
+            "items",
+            "items.variant",
+            "items.variant.product",
+            "payment_sessions",
+          ],
+        })
+
+        shipping_methods.forEach((method) => {
+          promises.push(
+            cartServiceTx.addShippingMethod(
+              createdCart,
               method.option_id,
               method.data
             )
+          )
+        })
+
+        await Promise.all(promises)
+
+        if (discounts?.length) {
+          await cartServiceTx.update(createdCart.id, { discounts })
         }
 
         return result

packages/medusa/src/services/line-item.ts

@@ -220,9 +220,11 @@ class LineItemService extends TransactionBaseService {
               quantity: quantity as number,
             }
           : variantIdOrData
+
         const resolvedContext = isString(variantIdOrData)
           ? context
           : (regionIdOrContext as GenerateLineItemContext)
+
         const regionId = (
           isString(variantIdOrData)
             ? regionIdOrContext
@@ -233,6 +235,10 @@ class LineItemService extends TransactionBaseService {
           Array.isArray(data) ? data : [data]
         ) as GenerateInputData[]
 
+        const resolvedDataMap = new Map(
+          resolvedData.map((d) => [d.variantId, d])
+        )
+
         const variants = await this.productVariantService_.list(
           {
             id: resolvedData.map((d) => d.variantId),
@@ -247,7 +253,11 @@ class LineItemService extends TransactionBaseService {
 
         for (const variant of variants) {
           variantsMap.set(variant.id, variant)
-          if (resolvedContext.unit_price == null) {
+          const variantResolvedData = resolvedDataMap.get(variant.id)
+          if (
+            resolvedContext.unit_price == null &&
+            variantResolvedData?.unit_price == null
+          ) {
             variantIdsToCalculatePricingFor.push(variant.id)
           }
         }
@@ -274,6 +284,8 @@ class LineItemService extends TransactionBaseService {
             variantData.quantity,
             {
               ...resolvedContext,
+              unit_price: variantData.unit_price ?? resolvedContext.unit_price,
+              metadata: variantData.metadata ?? resolvedContext.metadata,
               variantPricing,
             }
           )
@@ -313,8 +325,6 @@ class LineItemService extends TransactionBaseService {
       variantPricing: ProductVariantPricing
     }
   ): Promise<LineItem> {
-    const transactionManager = this.transactionManager_ ?? this.manager_
-
     let unit_price = Number(context.unit_price) < 0 ? 0 : context.unit_price
     let unitPriceIncludesTax = false
     let shouldMerge = false
@@ -350,9 +360,8 @@ class LineItemService extends TransactionBaseService {
 
     rawLineItem.order_edit_id = context.order_edit_id || null
 
-    const lineItemRepo = transactionManager.getCustomRepository(
+    const manager = this.transactionManager_ ?? this.manager_
-      this.lineItemRepository_
+    const lineItemRepo = manager.getCustomRepository(this.lineItemRepository_)
-    )
 
     const lineItem = lineItemRepo.create(rawLineItem)
     lineItem.variant = variant as ProductVariant

packages/medusa/src/types/line-item.ts

@@ -3,6 +3,8 @@ import { CalculationContextData } from "./totals"
 export type GenerateInputData = {
   variantId: string
   quantity: number
+  metadata?: Record<string, unknown>
+  unit_price?: number
 }
 
 export type GenerateLineItemContext = {