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

.changeset/afraid-moles-brake.md

@@ -0,0 +1,7 @@
+---
+"@medusajs/inventory": patch
+"@medusajs/medusa": patch
+"@medusajs/stock-location": patch
+---
+
+feat(medusa, stock-location, inventory): Allow modules to integrate with core

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,36 +1,42 @@
-import { ILike, In, getConnection, DeepPartial, EntityManager } from "typeorm"
+import { ILike, DeepPartial, EntityManager } from "typeorm"
 import { isDefined, MedusaError } from "medusa-core-utils"
 import {
   FindConfig,
   buildQuery,
   IEventBusService,
   FilterableInventoryItemProps,
   CreateInventoryItemInput,
+  InventoryItemDTO,
+  TransactionBaseService,
 } from "@medusajs/medusa"
 
 import { InventoryItem } from "../models"
-import { CONNECTION_NAME } from "../config"
 
 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",
     DELETED: "inventory-item.deleted",
   }
 
   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,7 +47,7 @@ export default class InventoryItemService {
   async list(
     selector: FilterableInventoryItemProps = {},
     config: FindConfig<InventoryItem> = { relations: [], skip: 0, take: 10 }
-  ): Promise<InventoryItem[]> {
+  ): Promise<InventoryItemDTO[]> {
     const queryBuilder = this.getListQuery(selector, config)
     return await queryBuilder.getMany()
   }
@@ -160,30 +166,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)
 
-    const result = await itemRepository.save(inventoryItem)
+      await this.eventBusService_
+        .withTransaction(manager)
+        .emit(InventoryItemService.Events.CREATED, {
+          id: result.id,
+        })
 
-    await this.eventBusService_.emit(InventoryItemService.Events.CREATED, {
-      id: result.id,
+      return result
     })
-
-    return result
   }
 
   /**
@@ -198,38 +207,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]
-    })
+      const shouldUpdate = Object.keys(data).some((key) => {
+        return item[key] !== data[key]
+      })
 
-    if (shouldUpdate) {
-      itemRepository.merge(item, data)
-      await itemRepository.save(item)
+      if (shouldUpdate) {
+        itemRepository.merge(item, data)
+        await itemRepository.save(item)
 
-      await this.eventBusService_.emit(InventoryItemService.Events.UPDATED, {
-        id: item.id,
-      })
-    }
+        await this.eventBusService_
+          .withTransaction(manager)
+          .emit(InventoryItemService.Events.UPDATED, {
+            id: item.id,
+          })
+      }
 
-    return item
+      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,
+        })
     })
   }