feat(cart): Shipping methods (#6101)

.changeset/olive-ads-brake.md

@@ -0,0 +1,5 @@
+---
+"@medusajs/types": patch
+---
+
+feat(cart): Shipping methods

packages/cart/integration-tests/__tests__/services/cart-module/index.spec.ts

@@ -1,4 +1,5 @@
 import { ICartModuleService } from "@medusajs/types"
+import { CheckConstraintViolationException } from "@mikro-orm/core"
 import { initialize } from "../../../../src/initialize"
 import { DB_URL, MikroOrmWrapper } from "../../../utils"
 
@@ -466,12 +467,9 @@ describe("Cart Module Service", () => {
 
       expect(item.title).toBe("test")
 
-      const updatedItem = await service.updateLineItems(
+      const updatedItem = await service.updateLineItems(item.id, {
-        item.id,
+        title: "test2",
-        {
+      })
-          title: "test2",
-        }
-      )
 
       expect(updatedItem.title).toBe("test2")
     })
@@ -519,13 +517,13 @@ describe("Cart Module Service", () => {
           selector: { cart_id: createdCart.id },
           data: {
             title: "changed-test",
-          }
+          },
         },
         {
           selector: { id: itemTwo!.id },
           data: {
             title: "changed-other-test",
-          }
+          },
         },
       ])
 
@@ -603,4 +601,117 @@ describe("Cart Module Service", () => {
       expect(cart.items?.length).toBe(0)
     })
   })
+
+  describe("addShippingMethods", () => {
+    it("should add a shipping method to cart succesfully", async () => {
+      const [createdCart] = await service.create([
+        {
+          currency_code: "eur",
+        },
+      ])
+
+      const [method] = await service.addShippingMethods(createdCart.id, [
+        {
+          amount: 100,
+          name: "Test",
+        },
+      ])
+
+      const cart = await service.retrieve(createdCart.id, {
+        relations: ["shipping_methods"],
+      })
+
+      expect(method.id).toBe(cart.shipping_methods![0].id)
+    })
+
+    it("should throw when amount is negative", async () => {
+      const [createdCart] = await service.create([
+        {
+          currency_code: "eur",
+        },
+      ])
+
+      const error = await service
+        .addShippingMethods(createdCart.id, [
+          {
+            amount: -100,
+            name: "Test",
+          },
+        ])
+        .catch((e) => e)
+
+      expect(error.name).toBe(CheckConstraintViolationException.name)
+    })
+
+    it("should add multiple shipping methods to multiple carts succesfully", async () => {
+      let [eurCart] = await service.create([
+        {
+          currency_code: "eur",
+        },
+      ])
+
+      let [usdCart] = await service.create([
+        {
+          currency_code: "usd",
+        },
+      ])
+
+      const methods = await service.addShippingMethods([
+        {
+          cart_id: eurCart.id,
+          amount: 100,
+          name: "Test One",
+        },
+        {
+          cart_id: usdCart.id,
+          amount: 100,
+          name: "Test One",
+        },
+      ])
+
+      const carts = await service.list(
+        { id: [eurCart.id, usdCart.id] },
+        { relations: ["shipping_methods"] }
+      )
+
+      eurCart = carts.find((c) => c.currency_code === "eur")!
+      usdCart = carts.find((c) => c.currency_code === "usd")!
+
+      const eurMethods = methods.filter((m) => m.cart_id === eurCart.id)
+      const usdMethods = methods.filter((m) => m.cart_id === usdCart.id)
+
+      expect(eurCart.shipping_methods![0].id).toBe(eurMethods[0].id)
+      expect(usdCart.shipping_methods![0].id).toBe(usdMethods[0].id)
+
+      expect(eurCart.shipping_methods?.length).toBe(1)
+      expect(usdCart.shipping_methods?.length).toBe(1)
+    })
+  })
+
+  describe("removeShippingMethods", () => {
+    it("should remove a line item succesfully", async () => {
+      const [createdCart] = await service.create([
+        {
+          currency_code: "eur",
+        },
+      ])
+
+      const [method] = await service.addShippingMethods(createdCart.id, [
+        {
+          amount: 100,
+          name: "test",
+        },
+      ])
+
+      expect(method.id).not.toBe(null)
+
+      await service.removeShippingMethods(method.id)
+
+      const cart = await service.retrieve(createdCart.id, {
+        relations: ["shipping_methods"],
+      })
+
+      expect(cart.shipping_methods?.length).toBe(0)
+    })
+  })
 })

packages/cart/src/loaders/container.ts

@@ -20,6 +20,9 @@ export default async ({
   container.register({
     cartService: asClass(defaultServices.CartService).singleton(),
     addressService: asClass(defaultServices.AddressService).singleton(),
+    shippingMethodService: asClass(
+      defaultServices.ShippingMethodService
+    ).singleton(),
     lineItemService: asClass(defaultServices.LineItemService).singleton(),
   })
 
@@ -38,7 +41,14 @@ function loadDefaultRepositories({ container }) {
   container.register({
     baseRepository: asClass(defaultRepositories.BaseRepository).singleton(),
     cartRepository: asClass(defaultRepositories.CartRepository).singleton(),
-    addressRepository: asClass(defaultRepositories.AddressRepository).singleton(),
+    addressRepository: asClass(
-    lineItemRepository: asClass(defaultRepositories.LineItemRepository).singleton(),
+      defaultRepositories.AddressRepository
+    ).singleton(),
+    lineItemRepository: asClass(
+      defaultRepositories.LineItemRepository
+    ).singleton(),
+    shippingMethodRepository: asClass(
+      defaultRepositories.ShippingMethodRepository
+    ).singleton(),
   })
 }

packages/cart/src/models/line-item.ts

@@ -94,13 +94,13 @@ export default class LineItem {
   @Property({ columnType: "jsonb", nullable: true })
   variant_option_values?: Record<string, unknown> | null
 
-  @Property({ columnType: "boolean", default: true })
+  @Property({ columnType: "boolean" })
   requires_shipping = true
 
-  @Property({ columnType: "boolean", default: true })
+  @Property({ columnType: "boolean" })
   is_discountable = true
 
-  @Property({ columnType: "boolean", default: false })
+  @Property({ columnType: "boolean" })
   is_tax_inclusive = false
 
   @Property({ columnType: "numeric", nullable: true })

packages/cart/src/models/shipping-method.ts

@@ -16,16 +16,20 @@ import ShippingMethodAdjustmentLine from "./shipping-method-adjustment-line"
 import ShippingMethodTaxLine from "./shipping-method-tax-line"
 
 @Entity({ tableName: "cart_shipping_method" })
+@Check<ShippingMethod>({ expression: (columns) => `${columns.amount} >= 0` })
 export default class ShippingMethod {
   @PrimaryKey({ columnType: "text" })
   id: string
 
+  @Property({ columnType: "text" })
+  cart_id: string
+
   @ManyToOne(() => Cart, {
     onDelete: "cascade",
     index: "IDX_shipping_method_cart_id",
-    fieldName: "cart_id",
+    nullable: true,
   })
-  cart: Cart
+  cart?: Cart | null
 
   @Property({ columnType: "text" })
   name: string
@@ -34,7 +38,6 @@ export default class ShippingMethod {
   description?: string | null
 
   @Property({ columnType: "numeric", serializer: Number })
-  @Check({ expression: "amount >= 0" }) // TODO: Validate that numeric types work with the expression
   amount: number
 
   @Property({ columnType: "boolean" })

packages/cart/src/repositories/address.ts

@@ -8,4 +8,9 @@ export class AddressRepository extends DALUtils.mikroOrmBaseRepositoryFactory<
     create: CreateAddressDTO
     update: UpdateAddressDTO
   }
->(Address) {}
+>(Address) {
+  constructor(...args: any[]) {
+    // @ts-ignore
+    super(...arguments)
+  }
+}

packages/cart/src/repositories/index.ts

@@ -2,4 +2,5 @@ export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
 export * from "./address"
 export * from "./cart"
 export * from "./line-item"
+export * from "./shipping-method"
 

packages/cart/src/repositories/line-item.ts

@@ -8,4 +8,9 @@ export class LineItemRepository extends DALUtils.mikroOrmBaseRepositoryFactory<
     create: CreateLineItemDTO
     update: UpdateLineItemDTO
   }
->(LineItem) {}
+>(LineItem) {
+  constructor(...args: any[]) {
+    // @ts-ignore
+    super(...arguments)
+  }
+}

packages/cart/src/repositories/shipping-method.ts

@@ -0,0 +1,16 @@
+import { DALUtils } from "@medusajs/utils"
+import { ShippingMethod } from "@models"
+import { CreateShippingMethodDTO, UpdateShippingMethodDTO } from "@types"
+
+export class ShippingMethodRepository extends DALUtils.mikroOrmBaseRepositoryFactory<
+  ShippingMethod,
+  {
+    create: CreateShippingMethodDTO
+    update: UpdateShippingMethodDTO
+  }
+>(ShippingMethod) {
+  constructor(...args: any[]) {
+    // @ts-ignore
+    super(...arguments)
+  }
+}

packages/cart/src/services/cart-module.ts

@@ -17,7 +17,7 @@ import {
   isObject,
   isString,
 } from "@medusajs/utils"
-import { LineItem } from "@models"
+import { LineItem, ShippingMethod } from "@models"
 import { UpdateLineItemDTO } from "@types"
 import { joinerConfig } from "../joiner-config"
 import * as services from "../services"
@@ -27,6 +27,7 @@ type InjectedDependencies = {
   cartService: services.CartService
   addressService: services.AddressService
   lineItemService: services.LineItemService
+  shippingMethodService: services.ShippingMethodService
 }
 
 export default class CartModuleService implements ICartModuleService {
@@ -34,6 +35,7 @@ export default class CartModuleService implements ICartModuleService {
   protected cartService_: services.CartService
   protected addressService_: services.AddressService
   protected lineItemService_: services.LineItemService
+  protected shippingMethodService_: services.ShippingMethodService
 
   constructor(
     {
@@ -41,6 +43,7 @@ export default class CartModuleService implements ICartModuleService {
       cartService,
       addressService,
       lineItemService,
+      shippingMethodService,
     }: InjectedDependencies,
     protected readonly moduleDeclaration: InternalModuleDeclaration
   ) {
@@ -48,6 +51,7 @@ export default class CartModuleService implements ICartModuleService {
     this.cartService_ = cartService
     this.addressService_ = addressService
     this.lineItemService_ = lineItemService
+    this.shippingMethodService_ = shippingMethodService
   }
 
   __joinerConfig(): ModuleJoinerConfig {
@@ -252,6 +256,25 @@ export default class CartModuleService implements ICartModuleService {
     )
   }
 
+  @InjectManager("baseRepository_")
+  async listShippingMethods(
+    filters: CartTypes.FilterableShippingMethodProps = {},
+    config: FindConfig<CartTypes.CartShippingMethodDTO> = {},
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<CartTypes.CartShippingMethodDTO[]> {
+    const methods = await this.shippingMethodService_.list(
+      filters,
+      config,
+      sharedContext
+    )
+
+    return await this.baseRepository_.serialize<
+      CartTypes.CartShippingMethodDTO[]
+    >(methods, {
+      populate: true,
+    })
+  }
+
   addLineItems(
     data: CartTypes.CreateLineItemForCartDTO
   ): Promise<CartTypes.CartLineItemDTO>
@@ -527,4 +550,112 @@ export default class CartModuleService implements ICartModuleService {
     const addressIds = Array.isArray(ids) ? ids : [ids]
     await this.addressService_.delete(addressIds, sharedContext)
   }
+
+  async addShippingMethods(
+    data: CartTypes.CreateShippingMethodDTO
+  ): Promise<CartTypes.CartShippingMethodDTO>
+  async addShippingMethods(
+    data: CartTypes.CreateShippingMethodDTO[]
+  ): Promise<CartTypes.CartShippingMethodDTO[]>
+  async addShippingMethods(
+    cartId: string,
+    methods: CartTypes.CreateShippingMethodDTO[],
+    sharedContext?: Context
+  ): Promise<CartTypes.CartShippingMethodDTO[]>
+
+  @InjectManager("baseRepository_")
+  async addShippingMethods(
+    cartIdOrData:
+      | string
+      | CartTypes.CreateShippingMethodDTO[]
+      | CartTypes.CreateShippingMethodDTO,
+    data?: CartTypes.CreateShippingMethodDTO[],
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<
+    CartTypes.CartShippingMethodDTO[] | CartTypes.CartShippingMethodDTO
+  > {
+    let methods: ShippingMethod[] = []
+    if (isString(cartIdOrData)) {
+      methods = await this.addShippingMethods_(
+        cartIdOrData,
+        data as CartTypes.CreateShippingMethodDTO[],
+        sharedContext
+      )
+    } else {
+      const data = Array.isArray(cartIdOrData) ? cartIdOrData : [cartIdOrData]
+      methods = await this.addShippingMethodsBulk_(data, sharedContext)
+    }
+
+    return await this.baseRepository_.serialize<
+      CartTypes.CartShippingMethodDTO[]
+    >(methods, {
+      populate: true,
+    })
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  protected async addShippingMethods_(
+    cartId: string,
+    data: CartTypes.CreateShippingMethodDTO[],
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<ShippingMethod[]> {
+    const cart = await this.retrieve(cartId, { select: ["id"] }, sharedContext)
+
+    const methods = data.map((method) => {
+      return {
+        ...method,
+        cart_id: cart.id,
+      }
+    })
+
+    return await this.addShippingMethodsBulk_(methods, sharedContext)
+  }
+
+  @InjectTransactionManager("baseRepository_")
+  protected async addShippingMethodsBulk_(
+    data: CartTypes.CreateShippingMethodDTO[],
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<ShippingMethod[]> {
+    return await this.shippingMethodService_.create(data, sharedContext)
+  }
+
+  async removeShippingMethods(
+    methodIds: string[],
+    sharedContext?: Context
+  ): Promise<void>
+  async removeShippingMethods(
+    methodIds: string,
+    sharedContext?: Context
+  ): Promise<void>
+  async removeShippingMethods(
+    selector: Partial<CartTypes.CartShippingMethodDTO>,
+    sharedContext?: Context
+  ): Promise<void>
+
+  @InjectTransactionManager("baseRepository_")
+  async removeShippingMethods(
+    methodIdsOrSelector:
+      | string
+      | string[]
+      | Partial<CartTypes.CartShippingMethodDTO>,
+    @MedusaContext() sharedContext: Context = {}
+  ): Promise<void> {
+    let toDelete: string[] = []
+    if (isObject(methodIdsOrSelector)) {
+      const methods = await this.listShippingMethods(
+        {
+          ...(methodIdsOrSelector as Partial<CartTypes.CartShippingMethodDTO>),
+        },
+        {},
+        sharedContext
+      )
+
+      toDelete = methods.map((m) => m.id)
+    } else {
+      toDelete = Array.isArray(methodIdsOrSelector)
+        ? methodIdsOrSelector
+        : [methodIdsOrSelector]
+    }
+    await this.shippingMethodService_.delete(toDelete, sharedContext)
+  }
 }

packages/cart/src/services/cart.ts

@@ -16,7 +16,7 @@ export default class CartService<
     update: UpdateCartDTO
   }
 >(Cart)<TEntity> {
-  constructor({ cartRepository }: InjectedDependencies) {
+  constructor(container: InjectedDependencies) {
     // @ts-ignore
     super(...arguments)
   }

packages/cart/src/services/index.ts

@@ -2,4 +2,5 @@ export { default as AddressService } from "./address"
 export { default as CartService } from "./cart"
 export { default as CartModuleService } from "./cart-module"
 export { default as LineItemService } from "./line-item"
+export { default as ShippingMethodService } from "./shipping-method"
 

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

@@ -1,7 +1,7 @@
 import { DAL } from "@medusajs/types"
 import { ModulesSdkUtils } from "@medusajs/utils"
 import { LineItem } from "@models"
-import { CreateLineItemDTO, UpdateLineItemDTO } from "../types"
+import { CreateLineItemDTO, UpdateLineItemDTO } from "@types"
 
 type InjectedDependencies = {
   lineItemRepository: DAL.RepositoryService
@@ -15,4 +15,9 @@ export default class LineItemService<
     create: CreateLineItemDTO
     update: UpdateLineItemDTO
   }
->(LineItem)<TEntity> {}
+>(LineItem)<TEntity> {
+  constructor(container: InjectedDependencies) {
+    // @ts-ignore
+    super(...arguments)
+  }
+}

packages/cart/src/services/shipping-method.ts

@@ -0,0 +1,23 @@
+import { DAL } from "@medusajs/types"
+import { ModulesSdkUtils } from "@medusajs/utils"
+import { ShippingMethod } from "@models"
+import { CreateShippingMethodDTO, UpdateShippingMethodDTO } from "../types"
+
+type InjectedDependencies = {
+  shippingMethodRepository: DAL.RepositoryService
+}
+
+export default class ShippingMethodService<
+  TEntity extends ShippingMethod = ShippingMethod
+> extends ModulesSdkUtils.abstractServiceFactory<
+  InjectedDependencies,
+  {
+    create: CreateShippingMethodDTO
+    update: UpdateShippingMethodDTO
+  }
+>(ShippingMethod)<TEntity> {
+  constructor(container: InjectedDependencies) {
+    // @ts-ignore
+    super(...arguments)
+  }
+}

packages/cart/src/types/index.ts

@@ -2,6 +2,7 @@ import { Logger } from "@medusajs/types"
 export * from "./address"
 export * from "./cart"
 export * from "./line-item"
+export * from "./shipping-method"
 
 export type InitializeModuleInjectableDependencies = {
   logger?: Logger

packages/cart/src/types/shipping-method.ts

@@ -0,0 +1,13 @@
+export interface CreateShippingMethodDTO {
+  name: string
+  cart_id: string
+  amount: number
+  data?: Record<string, unknown>
+}
+
+export interface UpdateShippingMethodDTO {
+  id: string
+  name?: string
+  amount?: number
+  data?: Record<string, unknown>
+}

packages/types/src/cart/common.ts

@@ -168,6 +168,11 @@ export interface CartShippingMethodDTO {
    */
   id: string
 
+  /**
+   * The ID of the associated cart
+   */
+  cart_id: string
+
   /**
    * The name of the shipping method
    */
@@ -489,8 +494,16 @@ export interface FilterableLineItemProps
   product_id?: string | string[]
 }
 
+export interface FilterableShippingMethodProps
+  extends BaseFilterable<FilterableShippingMethodProps> {
+  id?: string | string[]
+  cart_id?: string | string[]
+  name?: string
+  shipping_option_id?: string | string[]
+}
+
 /**
- * TODO: Remove this in favor of CartDTO, when module is released 
+ * TODO: Remove this in favor of CartDTO, when module is released
  * @deprecated Use CartDTO instead
  */
 export type legacy_CartDTO = {

packages/types/src/cart/mutations.ts

@@ -56,7 +56,7 @@ export interface UpdateCartDTO {
   metadata?: Record<string, unknown>
 }
 
-export interface CreateLineItemTaxLineDTO {
+export interface CreateTaxLineDTO {
   description?: string
   tax_rate_id?: string
   code: string
@@ -64,7 +64,7 @@ export interface CreateLineItemTaxLineDTO {
   provider_id?: string
 }
 
-export interface CreateLineItemAdjustmentDTO {
+export interface CreateAdjustmentDTO {
   code: string
   amount: number
   description?: string
@@ -72,7 +72,7 @@ export interface CreateLineItemAdjustmentDTO {
   provider_id?: string
 }
 
-export interface UpdateLineItemTaxLineDTO {
+export interface UpdateTaxLineDTO {
   id: string
   description?: string
   tax_rate_id?: string
@@ -81,7 +81,7 @@ export interface UpdateLineItemTaxLineDTO {
   provider_id?: string
 }
 
-export interface UpdateLineItemAdjustmentDTO {
+export interface UpdateAdjustmentDTO {
   id: string
   code?: string
   amount?: number
@@ -120,8 +120,8 @@ export interface CreateLineItemDTO {
   compare_at_unit_price?: number
   unit_price: number
 
-  tax_lines?: CreateLineItemTaxLineDTO[]
+  tax_lines?: CreateTaxLineDTO[]
-  adjustments?: CreateLineItemAdjustmentDTO[]
+  adjustments?: CreateAdjustmentDTO[]
 }
 
 export interface CreateLineItemForCartDTO extends CreateLineItemDTO {
@@ -144,6 +144,29 @@ export interface UpdateLineItemDTO
   quantity?: number
   unit_price?: number
 
-  tax_lines?: UpdateLineItemTaxLineDTO[] | CreateLineItemTaxLineDTO[]
+  tax_lines?: UpdateTaxLineDTO[] | CreateTaxLineDTO[]
-  adjustments?: UpdateLineItemAdjustmentDTO[] | CreateLineItemAdjustmentDTO[]
+  adjustments?: UpdateAdjustmentDTO[] | CreateAdjustmentDTO[]
+}
+
+export interface CreateShippingMethodDTO {
+  name: string
+
+  cart_id: string
+
+  amount: number
+  data?: Record<string, unknown>
+
+  tax_lines?: CreateTaxLineDTO[]
+  adjustments?: CreateAdjustmentDTO[]
+}
+
+export interface UpdateShippingMethodDTO {
+  id: string
+  name?: string
+
+  amount?: number
+  data?: Record<string, unknown>
+
+  tax_lines?: UpdateTaxLineDTO[] | CreateTaxLineDTO[]
+  adjustments?: UpdateAdjustmentDTO[] | CreateAdjustmentDTO[]
 }

packages/types/src/cart/service.ts

@@ -5,14 +5,17 @@ import {
   CartAddressDTO,
   CartDTO,
   CartLineItemDTO,
+  CartShippingMethodDTO,
   FilterableAddressProps,
   FilterableCartProps,
+  FilterableShippingMethodProps,
 } from "./common"
 import {
   CreateAddressDTO,
   CreateCartDTO,
   CreateLineItemDTO,
   CreateLineItemForCartDTO,
+  CreateShippingMethodDTO,
   UpdateAddressDTO,
   UpdateCartDTO,
   UpdateLineItemDTO,
@@ -102,4 +105,35 @@ export interface ICartModuleService extends IModuleService {
     selector: Partial<CartLineItemDTO>,
     sharedContext?: Context
   ): Promise<void>
+
+  listShippingMethods(
+    filters: FilterableShippingMethodProps,
+    config: FindConfig<CartShippingMethodDTO>,
+    sharedContext: Context
+  ): Promise<CartShippingMethodDTO[]>
+
+  addShippingMethods(
+    data: CreateShippingMethodDTO
+  ): Promise<CartShippingMethodDTO>
+  addShippingMethods(
+    data: CreateShippingMethodDTO[]
+  ): Promise<CartShippingMethodDTO[]>
+  addShippingMethods(
+    cartId: string,
+    methods: CreateShippingMethodDTO[],
+    sharedContext?: Context
+  ): Promise<CartShippingMethodDTO[]>
+
+  removeShippingMethods(
+    methodIds: string[],
+    sharedContext?: Context
+  ): Promise<void>
+  removeShippingMethods(
+    methodIds: string,
+    sharedContext?: Context
+  ): Promise<void>
+  removeShippingMethods(
+    selector: Partial<CartShippingMethodDTO>,
+    sharedContext?: Context
+  ): Promise<void>
 }