feat(medusa, stock-location, inventory): Allow modules to integrate with core (#2997)

* feat: module shared resources

packages/inventory/src/index.js

@@ -1,7 +0,0 @@
-import ConnectionLoader from "./loaders/connection"
-import InventoryService from "./services/inventory"
-import * as SchemaMigration from "./migrations/schema-migrations/1665748086258-inventory_setup"
-
-export const service = InventoryService
-export const migrations = [SchemaMigration]
-export const loaders = [ConnectionLoader]

packages/inventory/src/index.ts

@@ -0,0 +1,19 @@
+import ConnectionLoader from "./loaders/connection"
+import InventoryService from "./services/inventory"
+import * as InventoryModels from "./models"
+import * as SchemaMigration from "./migrations/schema-migrations/1665748086258-inventory_setup"
+import { ModuleExports } from "@medusajs/medusa"
+
+const service = InventoryService
+const migrations = [SchemaMigration]
+const loaders = [ConnectionLoader]
+const models = Object.values(InventoryModels)
+
+const moduleDefinition: ModuleExports = {
+  service,
+  migrations,
+  loaders,
+  models,
+}
+
+export default moduleDefinition

packages/inventory/src/loaders/connection.ts

@@ -1,22 +1,6 @@
-import { ConfigModule } from "@medusajs/medusa"
-import { ConnectionOptions, createConnection } from "typeorm"
-import { CONNECTION_NAME } from "../config"
+import { ConfigurableModuleDeclaration, LoaderOptions } from "@medusajs/medusa"
 
-import { ReservationItem, InventoryItem, InventoryLevel } from "../models"
-
-export default async ({
-  configModule,
-}: {
-  configModule: ConfigModule
-}): Promise<void> => {
-  await createConnection({
-    name: CONNECTION_NAME,
-    type: configModule.projectConfig.database_type,
-    url: configModule.projectConfig.database_url,
-    database: configModule.projectConfig.database_database,
-    schema: configModule.projectConfig.database_schema,
-    extra: configModule.projectConfig.database_extra || {},
-    entities: [ReservationItem, InventoryLevel, InventoryItem],
-    logging: configModule.projectConfig.database_logging || false,
-  } as ConnectionOptions)
-}
+export default async (
+  { configModule }: LoaderOptions,
+  moduleDeclaration?: ConfigurableModuleDeclaration
+): Promise<void> => {}

packages/inventory/src/services/inventory-item.ts

@@ -1,4 +1,4 @@
-import { ILike, In, getConnection, DeepPartial, EntityManager } from "typeorm"
+import { DeepPartial, EntityManager } from "typeorm"
 import { isDefined, MedusaError } from "medusa-core-utils"
 import {
   FindConfig,
@@ -6,16 +6,19 @@ import {
   IEventBusService,
   FilterableInventoryItemProps,
   CreateInventoryItemInput,
+  InventoryItemDTO,
+  TransactionBaseService,
 } from "@medusajs/medusa"
 
 import { InventoryItem } from "../models"
-import { CONNECTION_NAME } from "../config"
+import { getListQuery } from "../utils/query"
 
 type InjectedDependencies = {
   eventBusService: IEventBusService
+  manager: EntityManager
 }
 
-export default class InventoryItemService {
+export default class InventoryItemService extends TransactionBaseService {
   static Events = {
     CREATED: "inventory-item.created",
     UPDATED: "inventory-item.updated",
@@ -23,14 +26,18 @@ export default class InventoryItemService {
   }
 
   protected readonly eventBusService_: IEventBusService
+  protected manager_: EntityManager
+  protected transactionManager_: EntityManager | undefined
+
+  constructor({ eventBusService, manager }: InjectedDependencies) {
+    super(arguments[0])
 
-  constructor({ eventBusService }: InjectedDependencies) {
     this.eventBusService_ = eventBusService
+    this.manager_ = manager
   }
 
   private getManager(): EntityManager {
-    const connection = getConnection(CONNECTION_NAME)
-    return connection.manager
+    return this.transactionManager_ ?? this.manager_
   }
 
   /**
@@ -41,73 +48,11 @@ export default class InventoryItemService {
   async list(
     selector: FilterableInventoryItemProps = {},
     config: FindConfig<InventoryItem> = { relations: [], skip: 0, take: 10 }
-  ): Promise<InventoryItem[]> {
-    const queryBuilder = this.getListQuery(selector, config)
+  ): Promise<InventoryItemDTO[]> {
+    const queryBuilder = getListQuery(this.getManager(), selector, config)
     return await queryBuilder.getMany()
   }
 
-  private getListQuery(
-    selector: FilterableInventoryItemProps = {},
-    config: FindConfig<InventoryItem> = { relations: [], skip: 0, take: 10 }
-  ) {
-    const manager = this.getManager()
-    const inventoryItemRepository = manager.getRepository(InventoryItem)
-    const query = buildQuery(selector, config)
-
-    const queryBuilder = inventoryItemRepository.createQueryBuilder("inv_item")
-
-    if (query.where.q) {
-      query.where.sku = ILike(`%${query.where.q as string}%`)
-
-      delete query.where.q
-    }
-
-    if ("location_id" in query.where) {
-      const locationIds = Array.isArray(selector.location_id)
-        ? selector.location_id
-        : [selector.location_id]
-
-      queryBuilder.innerJoin(
-        "inventory_level",
-        "level",
-        "level.inventory_item_id = inv_item.id AND level.location_id IN (:...locationIds)",
-        { locationIds }
-      )
-
-      delete query.where.location_id
-    }
-
-    if (query.take) {
-      queryBuilder.take(query.take)
-    }
-
-    if (query.skip) {
-      queryBuilder.skip(query.skip)
-    }
-
-    if (query.where) {
-      queryBuilder.where(query.where)
-    }
-
-    if (query.select) {
-      queryBuilder.select(query.select.map((s) => "inv_item." + s))
-    }
-
-    if (query.order) {
-      const toSelect: string[] = []
-      const parsed = Object.entries(query.order).reduce((acc, [k, v]) => {
-        const key = `inv_item.${k}`
-        toSelect.push(key)
-        acc[key] = v
-        return acc
-      }, {})
-      queryBuilder.addSelect(toSelect)
-      queryBuilder.orderBy(parsed)
-    }
-
-    return queryBuilder
-  }
-
   /**
    * @param selector - Filter options for inventory items.
    * @param config - Configuration for query.
@@ -116,8 +61,8 @@ export default class InventoryItemService {
   async listAndCount(
     selector: FilterableInventoryItemProps = {},
     config: FindConfig<InventoryItem> = { relations: [], skip: 0, take: 10 }
-  ): Promise<[InventoryItem[], number]> {
-    const queryBuilder = this.getListQuery(selector, config)
+  ): Promise<[InventoryItemDTO[], number]> {
+    const queryBuilder = getListQuery(this.getManager(), selector, config)
     return await queryBuilder.getManyAndCount()
   }
 
@@ -160,30 +105,33 @@ export default class InventoryItemService {
    * @return The newly created inventory item.
    */
   async create(data: CreateInventoryItemInput): Promise<InventoryItem> {
-    const manager = this.getManager()
-    const itemRepository = manager.getRepository(InventoryItem)
+    return await this.atomicPhase_(async (manager) => {
+      const itemRepository = manager.getRepository(InventoryItem)
 
-    const inventoryItem = itemRepository.create({
-      sku: data.sku,
-      origin_country: data.origin_country,
-      metadata: data.metadata,
-      hs_code: data.hs_code,
-      mid_code: data.mid_code,
-      material: data.material,
-      weight: data.weight,
-      length: data.length,
-      height: data.height,
-      width: data.width,
-      requires_shipping: data.requires_shipping,
+      const inventoryItem = itemRepository.create({
+        sku: data.sku,
+        origin_country: data.origin_country,
+        metadata: data.metadata,
+        hs_code: data.hs_code,
+        mid_code: data.mid_code,
+        material: data.material,
+        weight: data.weight,
+        length: data.length,
+        height: data.height,
+        width: data.width,
+        requires_shipping: data.requires_shipping,
+      })
+
+      const result = await itemRepository.save(inventoryItem)
+
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(InventoryItemService.Events.CREATED, {
+          id: result.id,
+        })
+
+      return result
     })
-
-    const result = await itemRepository.save(inventoryItem)
-
-    await this.eventBusService_.emit(InventoryItemService.Events.CREATED, {
-      id: result.id,
-    })
-
-    return result
   }
 
   /**
@@ -198,38 +146,44 @@ export default class InventoryItemService {
       "id" | "created_at" | "metadata" | "deleted_at"
     >
   ): Promise<InventoryItem> {
-    const manager = this.getManager()
-    const itemRepository = manager.getRepository(InventoryItem)
+    return await this.atomicPhase_(async (manager) => {
+      const itemRepository = manager.getRepository(InventoryItem)
 
-    const item = await this.retrieve(inventoryItemId)
+      const item = await this.retrieve(inventoryItemId)
 
-    const shouldUpdate = Object.keys(data).some((key) => {
-      return item[key] !== data[key]
-    })
-
-    if (shouldUpdate) {
-      itemRepository.merge(item, data)
-      await itemRepository.save(item)
-
-      await this.eventBusService_.emit(InventoryItemService.Events.UPDATED, {
-        id: item.id,
+      const shouldUpdate = Object.keys(data).some((key) => {
+        return item[key] !== data[key]
       })
-    }
 
-    return item
+      if (shouldUpdate) {
+        itemRepository.merge(item, data)
+        await itemRepository.save(item)
+
+        await this.eventBusService_
+          .withTransaction(manager)
+          .emit(InventoryItemService.Events.UPDATED, {
+            id: item.id,
+          })
+      }
+
+      return item
+    })
   }
 
   /**
    * @param inventoryItemId - The id of the inventory item to delete.
    */
   async delete(inventoryItemId: string): Promise<void> {
-    const manager = this.getManager()
-    const itemRepository = manager.getRepository(InventoryItem)
+    await this.atomicPhase_(async (manager) => {
+      const itemRepository = manager.getRepository(InventoryItem)
 
-    await itemRepository.softRemove({ id: inventoryItemId })
+      await itemRepository.softRemove({ id: inventoryItemId })
 
-    await this.eventBusService_.emit(InventoryItemService.Events.DELETED, {
-      id: inventoryItemId,
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(InventoryItemService.Events.DELETED, {
+          id: inventoryItemId,
+        })
     })
   }
 }

packages/inventory/src/services/inventory-level.ts

@@ -1,4 +1,4 @@
-import { getConnection, DeepPartial, EntityManager } from "typeorm"
+import { DeepPartial, EntityManager } from "typeorm"
 import { isDefined, MedusaError } from "medusa-core-utils"
 import {
   FindConfig,
@@ -10,10 +10,10 @@ import {
 } from "@medusajs/medusa"
 
 import { InventoryLevel } from "../models"
-import { CONNECTION_NAME } from "../config"
 
 type InjectedDependencies = {
   eventBusService: IEventBusService
+  manager: EntityManager
 }
 
 export default class InventoryLevelService extends TransactionBaseService {
@@ -28,20 +28,15 @@ export default class InventoryLevelService extends TransactionBaseService {
 
   protected readonly eventBusService_: IEventBusService
 
-  constructor({ eventBusService }: InjectedDependencies) {
+  constructor({ eventBusService, manager }: InjectedDependencies) {
     super(arguments[0])
 
     this.eventBusService_ = eventBusService
-    this.manager_ = this.getManager()
+    this.manager_ = manager
   }
 
   private getManager(): EntityManager {
-    if (this.manager_) {
-      return this.transactionManager_ ?? this.manager_
-    }
-
-    const connection = getConnection(CONNECTION_NAME)
-    return connection.manager
+    return this.transactionManager_ ?? this.manager_
   }
 
   /**
@@ -118,7 +113,7 @@ export default class InventoryLevelService extends TransactionBaseService {
    * @return The created inventory level.
    */
   async create(data: CreateInventoryLevelInput): Promise<InventoryLevel> {
-    const result = await this.atomicPhase_(async (manager) => {
+    return await this.atomicPhase_(async (manager) => {
       const levelRepository = manager.getRepository(InventoryLevel)
 
       const inventoryLevel = levelRepository.create({
@@ -129,14 +124,15 @@ export default class InventoryLevelService extends TransactionBaseService {
         incoming_quantity: data.incoming_quantity,
       })
 
-      return await levelRepository.save(inventoryLevel)
-    })
+      const saved = await levelRepository.save(inventoryLevel)
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(InventoryLevelService.Events.CREATED, {
+          id: saved.id,
+        })
 
-    await this.eventBusService_.emit(InventoryLevelService.Events.CREATED, {
-      id: result.id,
+      return saved
     })
-
-    return result
   }
 
   /**
@@ -167,9 +163,11 @@ export default class InventoryLevelService extends TransactionBaseService {
         levelRepository.merge(item, data)
         await levelRepository.save(item)
 
-        await this.eventBusService_.emit(InventoryLevelService.Events.UPDATED, {
-          id: item.id,
-        })
+        await this.eventBusService_
+          .withTransaction(manager)
+          .emit(InventoryLevelService.Events.UPDATED, {
+            id: item.id,
+          })
       }
 
       return item
@@ -209,10 +207,12 @@ export default class InventoryLevelService extends TransactionBaseService {
       const levelRepository = manager.getRepository(InventoryLevel)
 
       await levelRepository.delete({ id: inventoryLevelId })
-    })
 
-    await this.eventBusService_.emit(InventoryLevelService.Events.DELETED, {
-      id: inventoryLevelId,
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(InventoryLevelService.Events.DELETED, {
+          id: inventoryLevelId,
+        })
     })
   }
 

packages/inventory/src/services/inventory.ts

@@ -14,6 +14,9 @@ import {
   InventoryItemDTO,
   ReservationItemDTO,
   InventoryLevelDTO,
+  TransactionBaseService,
+  ConfigurableModuleDeclaration,
+  MODULE_RESOURCE_TYPE,
 } from "@medusajs/medusa"
 
 import {
@@ -21,26 +24,52 @@ import {
   ReservationItemService,
   InventoryLevelService,
 } from "./"
+import { EntityManager } from "typeorm"
 
 type InjectedDependencies = {
+  manager: EntityManager
   eventBusService: IEventBusService
 }
 
-export default class InventoryService implements IInventoryService {
+export default class InventoryService
+  extends TransactionBaseService
+  implements IInventoryService
+{
   protected readonly eventBusService_: IEventBusService
+  protected manager_: EntityManager
+  protected transactionManager_: EntityManager | undefined
   protected readonly inventoryItemService_: InventoryItemService
   protected readonly reservationItemService_: ReservationItemService
   protected readonly inventoryLevelService_: InventoryLevelService
 
-  constructor({ eventBusService }: InjectedDependencies) {
-    this.eventBusService_ = eventBusService
+  constructor(
+    { eventBusService, manager }: InjectedDependencies,
+    options?: unknown,
+    moduleDeclaration?: ConfigurableModuleDeclaration
+  ) {
+    super(arguments[0])
 
-    this.inventoryItemService_ = new InventoryItemService({ eventBusService })
+    if (moduleDeclaration?.resources !== MODULE_RESOURCE_TYPE.SHARED) {
+      throw new MedusaError(
+        MedusaError.Types.INVALID_ARGUMENT,
+        "At the moment this module can only be used with shared resources"
+      )
+    }
+
+    this.eventBusService_ = eventBusService
+    this.manager_ = manager
+
+    this.inventoryItemService_ = new InventoryItemService({
+      eventBusService,
+      manager,
+    })
     this.inventoryLevelService_ = new InventoryLevelService({
       eventBusService,
+      manager,
     })
     this.reservationItemService_ = new ReservationItemService({
       eventBusService,
+      manager,
       inventoryLevelService: this.inventoryLevelService_,
     })
   }

packages/inventory/src/services/reservation-item.ts

@@ -1,4 +1,4 @@
-import { getConnection, DeepPartial, EntityManager } from "typeorm"
+import { EntityManager } from "typeorm"
 import { isDefined, MedusaError } from "medusa-core-utils"
 import {
   FindConfig,
@@ -16,6 +16,7 @@ import { InventoryLevelService } from "."
 
 type InjectedDependencies = {
   eventBusService: IEventBusService
+  manager: EntityManager
   inventoryLevelService: InventoryLevelService
 }
 
@@ -34,22 +35,18 @@ export default class ReservationItemService extends TransactionBaseService {
 
   constructor({
     eventBusService,
+    manager,
     inventoryLevelService,
   }: InjectedDependencies) {
     super(arguments[0])
 
-    this.manager_ = this.getManager()
+    this.manager_ = manager
     this.eventBusService_ = eventBusService
     this.inventoryLevelService_ = inventoryLevelService
   }
 
   private getManager(): EntityManager {
-    if (this.manager_) {
-      return this.transactionManager_ ?? this.manager_
-    }
-
-    const connection = getConnection(CONNECTION_NAME)
-    return connection.manager
+    return this.transactionManager_ ?? this.manager_
   }
 
   /**
@@ -126,7 +123,7 @@ export default class ReservationItemService extends TransactionBaseService {
    * @return The created reservation item.
    */
   async create(data: CreateReservationItemInput): Promise<ReservationItem> {
-    const result = await this.atomicPhase_(async (manager) => {
+    return await this.atomicPhase_(async (manager) => {
       const itemRepository = manager.getRepository(ReservationItem)
 
       const inventoryItem = itemRepository.create({
@@ -148,14 +145,14 @@ export default class ReservationItemService extends TransactionBaseService {
           ),
       ])
 
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(ReservationItemService.Events.CREATED, {
+          id: newInventoryItem.id,
+        })
+
       return newInventoryItem
     })
-
-    await this.eventBusService_.emit(ReservationItemService.Events.CREATED, {
-      id: result.id,
-    })
-
-    return result
   }
 
   /**
@@ -168,7 +165,7 @@ export default class ReservationItemService extends TransactionBaseService {
     reservationItemId: string,
     data: UpdateReservationItemInput
   ): Promise<ReservationItem> {
-    const updatedItem = await this.atomicPhase_(async (manager) => {
+    return await this.atomicPhase_(async (manager) => {
       const itemRepository = manager.getRepository(ReservationItem)
 
       const item = await this.retrieve(reservationItemId)
@@ -196,14 +193,14 @@ export default class ReservationItemService extends TransactionBaseService {
 
       await Promise.all(ops)
 
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(ReservationItemService.Events.UPDATED, {
+          id: mergedItem.id,
+        })
+
       return mergedItem
     })
-
-    await this.eventBusService_.emit(ReservationItemService.Events.UPDATED, {
-      id: updatedItem.id,
-    })
-
-    return updatedItem
   }
 
   /**
@@ -230,14 +227,13 @@ export default class ReservationItemService extends TransactionBaseService {
         )
       }
       await Promise.all(ops)
-    })
 
-    await this.eventBusService_.emit(
-      ReservationItemService.Events.DELETED_BY_LINE_ITEM,
-      {
-        line_item_id: lineItemId,
-      }
-    )
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(ReservationItemService.Events.DELETED_BY_LINE_ITEM, {
+          line_item_id: lineItemId,
+        })
+    })
   }
 
   /**

packages/inventory/src/utils/query.ts

@@ -0,0 +1,69 @@
+import { EntityManager, ILike } from "typeorm"
+import {
+  buildQuery,
+  FilterableInventoryItemProps,
+  FindConfig,
+} from "@medusajs/medusa"
+import { InventoryItem } from "../models"
+
+export function getListQuery(
+  manager: EntityManager,
+  selector: FilterableInventoryItemProps = {},
+  config: FindConfig<InventoryItem> = { relations: [], skip: 0, take: 10 }
+) {
+  const inventoryItemRepository = manager.getRepository(InventoryItem)
+  const query = buildQuery(selector, config)
+
+  const queryBuilder = inventoryItemRepository.createQueryBuilder("inv_item")
+
+  if (query.where.q) {
+    query.where.sku = ILike(`%${query.where.q as string}%`)
+
+    delete query.where.q
+  }
+
+  if ("location_id" in query.where) {
+    const locationIds = Array.isArray(selector.location_id)
+      ? selector.location_id
+      : [selector.location_id]
+
+    queryBuilder.innerJoin(
+      "inventory_level",
+      "level",
+      "level.inventory_item_id = inv_item.id AND level.location_id IN (:...locationIds)",
+      { locationIds }
+    )
+
+    delete query.where.location_id
+  }
+
+  if (query.take) {
+    queryBuilder.take(query.take)
+  }
+
+  if (query.skip) {
+    queryBuilder.skip(query.skip)
+  }
+
+  if (query.where) {
+    queryBuilder.where(query.where)
+  }
+
+  if (query.select) {
+    queryBuilder.select(query.select.map((s) => "inv_item." + s))
+  }
+
+  if (query.order) {
+    const toSelect: string[] = []
+    const parsed = Object.entries(query.order).reduce((acc, [k, v]) => {
+      const key = `inv_item.${k}`
+      toSelect.push(key)
+      acc[key] = v
+      return acc
+    }, {})
+    queryBuilder.addSelect(toSelect)
+    queryBuilder.orderBy(parsed)
+  }
+
+  return queryBuilder
+}