chore(): Autoload module resources (#7291)

**What**
- automatically build and consume connection and container loader if not exported by the module
- therefore load the services and repositories automatically, including baseRepository
- automatically build run and revert migrations if not provided
- cleaup modules to remove extra unnecessary bits and pieces
- remove the `initializeFactory` in favor of using `medusaApp`

Should drastically improve the module building DX by removing a lot of boilerplate to handle by the user, that plus the base entity should simplify quite a lot the flow cc @shahednasser 

**Note**
I had to choose a way to identify connection and container loader from the exported loader from the module. I decided to go with named function `connectionLoader` and `containerLoader`, also, now the factories will return named function so if the user use the factories we are providing to build those loaders, the function will also be named and identified
This commit is contained in:
Adrien de Peretti
2024-05-13 12:12:36 +00:00
committed by GitHub
parent 728c5ee53c
commit 63623422fe
112 changed files with 520 additions and 2320 deletions
-7
View File
@@ -1,14 +1,7 @@
import { moduleDefinition } from "./module-definition"
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
export * from "./types"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.API_KEY,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,8 @@
import { ModuleExports } from "@medusajs/types"
import * as ModuleServices from "@services"
import { ApiKeyModuleService } from "@services"
import { Modules } from "@medusajs/modules-sdk"
import * as Models from "@models"
import * as ModuleModels from "@models"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleRepositories from "@repositories"
const migrationScriptOptions = {
moduleName: Modules.API_KEY,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.API_KEY,
moduleModels: Object.values(Models),
migrationsPath: __dirname + "/migrations",
})
const service = ApiKeyModuleService
const loaders = [containerLoader, connectionLoader] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
+1 -7
View File
@@ -1,11 +1,5 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
export * from "./loaders"
@@ -1,31 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import { IAuthModuleService, ModulesSdkTypes } from "@medusajs/types"
import { InitializeModuleInjectableDependencies } from "@types"
import { moduleDefinition } from "../module-definition"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleBootstrapDeclaration
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IAuthModuleService> => {
const loaded = await MedusaModule.bootstrap<IAuthModuleService>({
moduleKey: Modules.AUTH,
defaultPath: MODULE_PACKAGE_NAMES[Modules.AUTH],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration, // TODO: Add provider configuration
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.AUTH]
}
@@ -1,38 +0,0 @@
import * as AuthModels from "../models"
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { EntitySchema } from "@mikro-orm/core"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(
AuthModels
) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.AUTH,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,3 +1 @@
export * from "./connection"
export * from "./container"
export * from "./providers"
+1 -22
View File
@@ -1,32 +1,11 @@
import * as Models from "@models"
import { AuthModuleService } from "@services"
import { ModuleExports } from "@medusajs/types"
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
import loadProviders from "./loaders/providers"
const migrationScriptOptions = {
moduleName: Modules.AUTH,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = AuthModuleService
const loaders = [loadContainer, loadConnection, loadProviders] as any
const loaders = [loadProviders] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
+1 -8
View File
@@ -1,10 +1,3 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
@@ -1,31 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import { ICartModuleService, ModulesSdkTypes } from "@medusajs/types"
import { moduleDefinition } from "../module-definition"
import { InitializeModuleInjectableDependencies } from "@types"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<ICartModuleService> => {
const loaded = await MedusaModule.bootstrap<ICartModuleService>({
moduleKey: Modules.CART,
defaultPath: MODULE_PACKAGE_NAMES[Modules.CART],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.CART]
}
@@ -1,36 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as CartModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(
CartModels
) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.CART,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,30 +1,8 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as Models from "@models"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
import { CartModuleService } from "./services"
const migrationScriptOptions = {
moduleName: Modules.CART,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = CartModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
-7
View File
@@ -1,14 +1,7 @@
import { moduleDefinition } from "./module-definition"
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
export * from "./types"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.CURRENCY,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,45 +1,11 @@
import { ModuleExports } from "@medusajs/types"
import * as ModuleServices from "@services"
import { CurrencyModuleService } from "@services"
import { Modules } from "@medusajs/modules-sdk"
import * as Models from "@models"
import * as ModuleModels from "@models"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleRepositories from "@repositories"
import initialDataLoader from "./loaders/initial-data"
const migrationScriptOptions = {
moduleName: Modules.CURRENCY,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.CURRENCY,
moduleModels: Object.values(Models),
migrationsPath: __dirname + "/migrations",
})
const service = CurrencyModuleService
const loaders = [containerLoader, connectionLoader, initialDataLoader] as any
const loaders = [initialDataLoader]
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
+1 -8
View File
@@ -1,10 +1,3 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
@@ -1,31 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import { ICustomerModuleService, ModulesSdkTypes } from "@medusajs/types"
import { moduleDefinition } from "../module-definition"
import { InitializeModuleInjectableDependencies } from "@types"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<ICustomerModuleService> => {
const loaded = await MedusaModule.bootstrap<ICustomerModuleService>({
moduleKey: Modules.CUSTOMER,
defaultPath: MODULE_PACKAGE_NAMES[Modules.CUSTOMER],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.CUSTOMER]
}
@@ -1,34 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as CustomerModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(CustomerModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.CUSTOMER,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,11 +0,0 @@
import * as ModuleModels from "@models"
import * as CustomerRepositories from "@repositories"
import * as ModuleServices from "@services"
import { ModulesSdkUtils } from "@medusajs/utils"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleServices: ModuleServices,
moduleRepositories: CustomerRepositories,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,31 +1,8 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as Models from "@models"
import { CustomerModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
const migrationScriptOptions = {
moduleName: Modules.CUSTOMER,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const service = CustomerModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
-8
View File
@@ -1,13 +1,5 @@
import { moduleDefinition } from "./module-definition"
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
export * from "./types"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.FILE,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
+1 -18
View File
@@ -1,28 +1,11 @@
import { ModuleExports } from "@medusajs/types"
import { FileModuleService } from "@services"
import loadProviders from "./loaders/providers"
import * as ModuleServices from "@services"
import { ModulesSdkUtils } from "@medusajs/utils"
export const runMigrations = () => {
return Promise.resolve()
}
export const revertMigration = () => {
return Promise.resolve()
}
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: {},
moduleRepositories: {},
moduleServices: ModuleServices,
})
const loaders = [containerLoader, loadProviders] as any
const loaders = [loadProviders] as any
const service = FileModuleService
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
@@ -1,14 +1,7 @@
import { moduleDefinition } from "./module-definition"
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
export * from "./types"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.FULFILLMENT,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,11 @@
import { ModuleExports } from "@medusajs/types"
import * as ModuleServices from "@services"
import { FulfillmentModuleService } from "@services"
import { Modules } from "@medusajs/modules-sdk"
import * as ModuleModels from "@models"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleRepositories from "@repositories"
import loadProviders from "./loaders/providers"
const migrationScriptOptions = {
moduleName: Modules.FULFILLMENT,
models: ModuleModels,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.FULFILLMENT,
moduleModels: Object.values(ModuleModels),
migrationsPath: __dirname + "/migrations",
})
const service = FulfillmentModuleService
const loaders = [containerLoader, connectionLoader, loadProviders]
const loaders = [loadProviders]
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
@@ -1,14 +1,6 @@
import { Modules, initializeFactory } from "@medusajs/modules-sdk"
import { moduleDefinition } from "./module-definition"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.INVENTORY,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,8 @@
import * as InventoryModels from "@models"
import * as InventoryRepositories from "@repositories"
import * as InventoryServices from "@services"
import InventoryService from "./services/inventory"
import { ModuleExports } from "@medusajs/types"
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
const migrationScriptOptions = {
moduleName: Modules.INVENTORY,
models: InventoryModels,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: InventoryModels,
moduleRepositories: InventoryRepositories,
moduleServices: InventoryServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.INVENTORY,
moduleModels: Object.values(InventoryModels),
migrationsPath: __dirname + "/migrations",
})
const service = InventoryService
const loaders = [containerLoader, connectionLoader]
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
@@ -1,14 +1,7 @@
import { moduleDefinition } from "./module-definition"
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
export * from "./types"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.NOTIFICATION,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,11 @@
import { ModuleExports } from "@medusajs/types"
import * as ModuleServices from "@services"
import { NotificationModuleService } from "@services"
import { Modules } from "@medusajs/modules-sdk"
import * as ModuleModels from "@models"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleRepositories from "@repositories"
import loadProviders from "./loaders/providers"
const migrationScriptOptions = {
moduleName: Modules.NOTIFICATION,
models: ModuleModels,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.NOTIFICATION,
moduleModels: Object.values(ModuleModels),
migrationsPath: __dirname + "/migrations",
})
const service = NotificationModuleService
const loaders = [containerLoader, connectionLoader, loadProviders]
const loaders = [loadProviders]
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
@@ -1 +0,0 @@
export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
-7
View File
@@ -1,14 +1,7 @@
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
import { moduleDefinition } from "./module-definition"
export * from "./models"
export * from "./services"
export * from "./types"
export const initialize = initializeFactory({
moduleName: Modules.ORDER,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,8 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as Models from "@models"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
import { OrderModuleService } from "@services"
const migrationScriptOptions = {
moduleName: Modules.ORDER,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.ORDER,
moduleModels: Object.values(Models),
migrationsPath: __dirname + "/migrations",
})
const service = OrderModuleService
const loaders = [containerLoader, connectionLoader] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
+1 -7
View File
@@ -1,11 +1,5 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
export * from "./types"
@@ -1,38 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import {
IPaymentModuleService,
ModuleProvider,
ModulesSdkTypes,
} from "@medusajs/types"
import { moduleDefinition } from "../module-definition"
import { InitializeModuleInjectableDependencies } from "../types"
export const initialize = async (
options?:
| (
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration
) & { providers: ModuleProvider[] },
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IPaymentModuleService> => {
const loaded = await MedusaModule.bootstrap<IPaymentModuleService>({
moduleKey: Modules.PAYMENT,
defaultPath: MODULE_PACKAGE_NAMES[Modules.PAYMENT],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.PAYMENT]
}
@@ -1,34 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as PaymentModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(PaymentModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.PAYMENT,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,4 +1,2 @@
export * from "./connection"
export * from "./container"
export * from "./providers"
export * from "./defaults"
@@ -1,41 +1,13 @@
import { ModuleExports } from "@medusajs/types"
import { PaymentModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
import loadProviders from "./loaders/providers"
import loadDefaults from "./loaders/defaults"
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as PaymentModels from "@models"
const migrationScriptOptions = {
moduleName: Modules.PAYMENT,
models: PaymentModels,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = PaymentModuleService
const loaders = [
loadContainer,
loadConnection,
loadProviders,
loadDefaults,
] as any
const loaders = [loadProviders, loadDefaults] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
+1 -8
View File
@@ -1,14 +1,7 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
// TODO: remove export from models and services
export * from "./models"
export * from "./services"
export * from "./types"
@@ -1,34 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MODULE_PACKAGE_NAMES,
MedusaModule,
Modules,
} from "@medusajs/modules-sdk"
import { IPricingModuleService, ModulesSdkTypes } from "@medusajs/types"
import { InitializeModuleInjectableDependencies } from "@types"
import { moduleDefinition } from "../module-definition"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IPricingModuleService> => {
const serviceKey = Modules.PRICING
const loaded = await MedusaModule.bootstrap<IPricingModuleService>({
moduleKey: serviceKey,
defaultPath: MODULE_PACKAGE_NAMES[Modules.PRICING],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[serviceKey]
}
@@ -1,30 +0,0 @@
import { InternalModuleDeclaration, LoaderOptions } from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as PricingModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(PricingModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: "pricing",
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,30 +1,8 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as Models from "@models"
import { PricingModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
const migrationScriptOptions = {
moduleName: Modules.PRICING,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = PricingModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
+1 -8
View File
@@ -1,14 +1,7 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
// TODO: remove export from models and services
export * from "./models"
export * from "./services"
export * from "./types"
@@ -1,34 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import { IProductModuleService, ModulesSdkTypes } from "@medusajs/types"
import { InitializeModuleInjectableDependencies } from "@types"
import { moduleDefinition } from "../module-definition"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IProductModuleService> => {
const serviceKey = Modules.PRODUCT
const loaded = await MedusaModule.bootstrap<IProductModuleService>({
moduleKey: serviceKey,
defaultPath: MODULE_PACKAGE_NAMES[Modules.PRODUCT],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[serviceKey]
}
@@ -1,30 +0,0 @@
import { InternalModuleDeclaration, LoaderOptions } from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as ProductModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(ProductModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: "product",
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,31 +1,8 @@
import { ModuleExports } from "@medusajs/types"
import { ProductModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ProductModels from "@models"
const migrationScriptOptions = {
moduleName: Modules.PRODUCT,
models: ProductModels,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = ProductModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
@@ -1,3 +1,2 @@
export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
export { ProductRepository } from "./product"
export { ProductCategoryRepository } from "./product-category"
@@ -1,17 +0,0 @@
import { asValue } from "awilix"
export const nonExistingProductId = "non-existing-id"
export const productRepositoryMock = {
productRepository: asValue({
find: jest.fn().mockImplementation(async ({ where: { id } }) => {
if (id === nonExistingProductId) {
return []
}
return [{}]
}),
findAndCount: jest.fn().mockResolvedValue([[], 0]),
getFreshManager: jest.fn().mockResolvedValue({}),
}),
}
@@ -0,0 +1 @@
it("noop", () => {})
@@ -1,227 +0,0 @@
import {
nonExistingProductId,
productRepositoryMock,
} from "../__fixtures__/product"
import { createMedusaContainer } from "@medusajs/utils"
import { asValue } from "awilix"
import ContainerLoader from "../../loaders/container"
describe("Product service", function () {
let container
beforeEach(async function () {
jest.clearAllMocks()
container = createMedusaContainer()
container.register("manager", asValue({}))
await ContainerLoader({ container })
container.register(productRepositoryMock)
})
it("should retrieve a product", async function () {
const productService = container.resolve("productService")
const productRepository = container.resolve("productRepository")
const productId = "existing-product"
await productService.retrieve(productId)
expect(productRepository.find).toHaveBeenCalledWith(
{
where: {
id: productId,
},
options: {
fields: undefined,
limit: undefined,
offset: 0,
populate: [],
withDeleted: undefined,
},
},
expect.any(Object)
)
})
it("should fail to retrieve a product", async function () {
const productService = container.resolve("productService")
const productRepository = container.resolve("productRepository")
const err = await productService
.retrieve(nonExistingProductId)
.catch((e) => e)
expect(productRepository.find).toHaveBeenCalledWith(
{
where: {
id: nonExistingProductId,
},
options: {
fields: undefined,
limit: undefined,
offset: 0,
populate: [],
withDeleted: undefined,
},
},
expect.any(Object)
)
expect(err.message).toBe(
`Product with id: ${nonExistingProductId} was not found`
)
})
it("should list products", async function () {
const productService = container.resolve("productService")
const productRepository = container.resolve("productRepository")
const filters = {}
const config = {
relations: [],
}
await productService.list(filters, config)
expect(productRepository.find).toHaveBeenCalledWith(
{
where: {},
options: {
fields: undefined,
limit: 15,
offset: 0,
orderBy: {
id: "ASC",
},
populate: [],
withDeleted: undefined,
},
},
expect.any(Object)
)
})
it("should list products with filters", async function () {
const productService = container.resolve("productService")
const productRepository = container.resolve("productRepository")
const filters = {
tags: {
value: {
$in: ["test"],
},
},
}
const config = {
relations: [],
}
await productService.list(filters, config)
expect(productRepository.find).toHaveBeenCalledWith(
{
where: {
tags: {
value: {
$in: ["test"],
},
},
},
options: {
fields: undefined,
limit: 15,
offset: 0,
orderBy: {
id: "ASC",
},
populate: [],
withDeleted: undefined,
},
},
expect.any(Object)
)
})
it("should list products with filters and relations", async function () {
const productService = container.resolve("productService")
const productRepository = container.resolve("productRepository")
const filters = {
tags: {
value: {
$in: ["test"],
},
},
}
const config = {
relations: ["tags"],
}
await productService.list(filters, config)
expect(productRepository.find).toHaveBeenCalledWith(
{
where: {
tags: {
value: {
$in: ["test"],
},
},
},
options: {
fields: undefined,
limit: 15,
offset: 0,
orderBy: {
id: "ASC",
},
withDeleted: undefined,
populate: ["tags"],
},
},
expect.any(Object)
)
})
it("should list and count the products with filters and relations", async function () {
const productService = container.resolve("productService")
const productRepository = container.resolve("productRepository")
const filters = {
tags: {
value: {
$in: ["test"],
},
},
}
const config = {
relations: ["tags"],
}
await productService.listAndCount(filters, config)
expect(productRepository.findAndCount).toHaveBeenCalledWith(
{
where: {
tags: {
value: {
$in: ["test"],
},
},
},
options: {
fields: undefined,
limit: 15,
offset: 0,
orderBy: {
id: "ASC",
},
withDeleted: undefined,
populate: ["tags"],
},
},
expect.any(Object)
)
})
})
+1 -8
View File
@@ -1,10 +1,3 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
@@ -1,31 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MODULE_PACKAGE_NAMES,
MedusaModule,
Modules,
} from "@medusajs/modules-sdk"
import { IPromotionModuleService, ModulesSdkTypes } from "@medusajs/types"
import { moduleDefinition } from "../module-definition"
import { InitializeModuleInjectableDependencies } from "../types"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IPromotionModuleService> => {
const loaded = await MedusaModule.bootstrap<IPromotionModuleService>({
moduleKey: Modules.PROMOTION,
defaultPath: MODULE_PACKAGE_NAMES[Modules.PROMOTION],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.PROMOTION]
}
@@ -1,34 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as PromotionModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(PromotionModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.PROMOTION,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,30 +1,8 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as Models from "@models"
import { PromotionModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
const migrationScriptOptions = {
moduleName: Modules.PROMOTION,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = PromotionModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
+1 -8
View File
@@ -1,10 +1,3 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
@@ -1,34 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import { IRegionModuleService, ModulesSdkTypes } from "@medusajs/types"
import { InitializeModuleInjectableDependencies } from "@types"
import { moduleDefinition } from "../module-definition"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IRegionModuleService> => {
const serviceKey = Modules.REGION
const loaded = await MedusaModule.bootstrap<IRegionModuleService>({
moduleKey: serviceKey,
defaultPath: MODULE_PACKAGE_NAMES[Modules.REGION],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[serviceKey]
}
@@ -1,35 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as RegionModels from "@models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(RegionModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.REGION,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,4 +1 @@
export * from "./connection"
export * from "./container"
export * from "./defaults"
@@ -1,32 +1,11 @@
import { ModuleExports } from "@medusajs/types"
import { RegionModuleService } from "./services"
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as RegionModels from "@models"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
import loadDefaults from "./loaders/defaults"
const migrationScriptOptions = {
moduleName: Modules.REGION,
models: RegionModels,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = RegionModuleService
const loaders = [loadContainer, loadConnection, loadDefaults] as any
const loaders = [loadDefaults]
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
@@ -2,242 +2,241 @@ import { SqlEntityManager } from "@mikro-orm/postgresql"
import { ISalesChannelModuleService } from "@medusajs/types"
import { initialize } from "../../../src"
import { createSalesChannels } from "../../__fixtures__"
import { DB_URL, MikroOrmWrapper } from "../../utils"
import { moduleIntegrationTestRunner, SuiteOptions } from "medusa-test-utils"
import { Modules } from "@medusajs/modules-sdk"
jest.setTimeout(30000)
describe("Sales Channel Service", () => {
let service: ISalesChannelModuleService
let testManager: SqlEntityManager
let repositoryManager: SqlEntityManager
moduleIntegrationTestRunner({
moduleName: Modules.SALES_CHANNEL,
testSuite: ({
MikroOrmWrapper,
medusaApp,
}: SuiteOptions<ISalesChannelModuleService>) => {
let service: ISalesChannelModuleService
beforeEach(async () => {
await MikroOrmWrapper.setupDatabase()
repositoryManager = await MikroOrmWrapper.forkManager()
service = await initialize({
database: {
clientUrl: DB_URL,
schema: process.env.MEDUSA_SALES_CHANNEL_DB_SCHEMA,
},
beforeEach(() => {
service = medusaApp.modules[Modules.SALES_CHANNEL]
})
testManager = await MikroOrmWrapper.forkManager()
describe("Sales Channel Service", () => {
let testManager: SqlEntityManager
let repositoryManager: SqlEntityManager
await createSalesChannels(testManager)
})
beforeEach(async () => {
repositoryManager = await MikroOrmWrapper.forkManager()
testManager = await MikroOrmWrapper.forkManager()
afterEach(async () => {
await MikroOrmWrapper.clearDatabase()
})
describe("create", () => {
it("should create a SalesChannel successfully", async () => {
const [created] = await service.create([
{
name: "test",
description: "test",
},
])
const [channel] = await service.list({
name: [created.name],
await createSalesChannels(testManager)
})
expect(channel.name).toEqual("test")
expect(channel.description).toEqual("test")
})
})
describe("create", () => {
it("should create a SalesChannel successfully", async () => {
const [created] = await service.create([
{
name: "test",
description: "test",
},
])
describe("retrieve", () => {
const id = "channel-1"
const [channel] = await service.list({
name: [created.name],
})
it("should return SalesChannel for the given id", async () => {
const result = await service.retrieve(id)
expect(result).toEqual(
expect.objectContaining({
id,
expect(channel.name).toEqual("test")
expect(channel.description).toEqual("test")
})
)
})
it("should throw an error when SalesChannelId with id does not exist", async () => {
let error
try {
await service.retrieve("does-not-exist")
} catch (e) {
error = e
}
expect(error.message).toEqual(
"SalesChannel with id: does-not-exist was not found"
)
})
})
describe("update", () => {
const id = "channel-2"
it("should update the name of the SalesChannel successfully", async () => {
await service.update(id, {
name: "Update name 2",
is_disabled: true,
})
const channel = await service.retrieve(id)
describe("retrieve", () => {
const id = "channel-1"
expect(channel.name).toEqual("Update name 2")
expect(channel.is_disabled).toEqual(true)
})
it("should return SalesChannel for the given id", async () => {
const result = await service.retrieve(id)
it("should throw an error when a id does not exist", async () => {
let error
try {
await service.update("does-not-exist", {
name: "does-not-exist",
expect(result).toEqual(
expect.objectContaining({
id,
})
)
})
} catch (e) {
error = e
}
expect(error.message).toEqual(
'SalesChannel with id "does-not-exist" not found'
)
})
})
it("should throw an error when SalesChannelId with id does not exist", async () => {
let error
describe("list", () => {
it("should return a list of SalesChannels", async () => {
const result = await service.list()
try {
await service.retrieve("does-not-exist")
} catch (e) {
error = e
}
expect(result).toEqual([
expect.objectContaining({
id: "channel-1",
}),
expect.objectContaining({
id: "channel-2",
}),
expect.objectContaining({
id: "channel-3",
}),
])
})
it("should list SalesChannels by name", async () => {
const result = await service.list({
name: ["Channel 2", "Channel 3"],
expect(error.message).toEqual(
"SalesChannel with id: does-not-exist was not found"
)
})
})
expect(result).toEqual([
expect.objectContaining({
id: "channel-2",
}),
expect.objectContaining({
id: "channel-3",
}),
])
})
})
describe("update", () => {
const id = "channel-2"
describe("listAndCount", () => {
it("should return sales channels and count", async () => {
const [result, count] = await service.listAndCount()
it("should update the name of the SalesChannel successfully", async () => {
await service.update(id, {
name: "Update name 2",
is_disabled: true,
})
expect(count).toEqual(3)
expect(result).toEqual([
expect.objectContaining({
id: "channel-1",
}),
expect.objectContaining({
id: "channel-2",
}),
expect.objectContaining({
id: "channel-3",
}),
])
})
const channel = await service.retrieve(id)
it("should return sales channels and count when filtered", async () => {
const [result, count] = await service.listAndCount({
id: ["channel-2"],
expect(channel.name).toEqual("Update name 2")
expect(channel.is_disabled).toEqual(true)
})
it("should throw an error when a id does not exist", async () => {
let error
try {
await service.update("does-not-exist", {
name: "does-not-exist",
})
} catch (e) {
error = e
}
expect(error.message).toEqual(
'SalesChannel with id "does-not-exist" not found'
)
})
})
expect(count).toEqual(1)
expect(result).toEqual([
expect.objectContaining({
id: "channel-2",
}),
])
})
describe("list", () => {
it("should return a list of SalesChannels", async () => {
const result = await service.list()
it("should return sales channels and count when using skip and take", async () => {
const [results, count] = await service.listAndCount(
{},
{ skip: 1, take: 1 }
)
expect(result).toEqual([
expect.objectContaining({
id: "channel-1",
}),
expect.objectContaining({
id: "channel-2",
}),
expect.objectContaining({
id: "channel-3",
}),
])
})
expect(count).toEqual(3)
expect(results).toEqual([
expect.objectContaining({
id: "channel-2",
}),
])
})
it("should list SalesChannels by name", async () => {
const result = await service.list({
name: ["Channel 2", "Channel 3"],
})
it("should return requested fields", async () => {
const [result, count] = await service.listAndCount(
{},
{
take: 1,
select: ["id", "name"],
}
)
const serialized = JSON.parse(JSON.stringify(result))
expect(count).toEqual(3)
expect(serialized).toEqual([
{
id: "channel-1",
name: "Channel 1",
},
])
})
it("should filter disabled channels", async () => {
const [result, count] = await service.listAndCount(
{ is_disabled: true },
{ select: ["id"] }
)
const serialized = JSON.parse(JSON.stringify(result))
expect(count).toEqual(1)
expect(serialized).toEqual([
{
id: "channel-3",
},
])
})
})
describe("delete", () => {
const id = "channel-2"
it("should delete the SalesChannel given an id successfully", async () => {
await service.delete([id])
const result = await service.list({
id: [id],
expect(result).toEqual([
expect.objectContaining({
id: "channel-2",
}),
expect.objectContaining({
id: "channel-3",
}),
])
})
})
expect(result).toHaveLength(0)
describe("listAndCount", () => {
it("should return sales channels and count", async () => {
const [result, count] = await service.listAndCount()
expect(count).toEqual(3)
expect(result).toEqual([
expect.objectContaining({
id: "channel-1",
}),
expect.objectContaining({
id: "channel-2",
}),
expect.objectContaining({
id: "channel-3",
}),
])
})
it("should return sales channels and count when filtered", async () => {
const [result, count] = await service.listAndCount({
id: ["channel-2"],
})
expect(count).toEqual(1)
expect(result).toEqual([
expect.objectContaining({
id: "channel-2",
}),
])
})
it("should return sales channels and count when using skip and take", async () => {
const [results, count] = await service.listAndCount(
{},
{ skip: 1, take: 1 }
)
expect(count).toEqual(3)
expect(results).toEqual([
expect.objectContaining({
id: "channel-2",
}),
])
})
it("should return requested fields", async () => {
const [result, count] = await service.listAndCount(
{},
{
take: 1,
select: ["id", "name"],
}
)
const serialized = JSON.parse(JSON.stringify(result))
expect(count).toEqual(3)
expect(serialized).toEqual([
{
id: "channel-1",
name: "Channel 1",
},
])
})
it("should filter disabled channels", async () => {
const [result, count] = await service.listAndCount(
{ is_disabled: true },
{ select: ["id"] }
)
const serialized = JSON.parse(JSON.stringify(result))
expect(count).toEqual(1)
expect(serialized).toEqual([
{
id: "channel-3",
},
])
})
})
describe("delete", () => {
const id = "channel-2"
it("should delete the SalesChannel given an id successfully", async () => {
await service.delete([id])
const result = await service.list({
id: [id],
})
expect(result).toHaveLength(0)
})
})
})
})
},
})
@@ -1,27 +1,7 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as SalesChannelModels from "@models"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
const migrationScriptOptions = {
moduleName: Modules.SALES_CHANNEL,
models: SalesChannelModels,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
export * from "./initialize"
export * from "./types"
export * from "./loaders"
export * from "./models"
export * from "./services"
@@ -1,34 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MedusaModule,
MODULE_PACKAGE_NAMES,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes, ISalesChannelModuleService } from "@medusajs/types"
import { InitializeModuleInjectableDependencies } from "@types"
import { moduleDefinition } from "../module-definition"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<ISalesChannelModuleService> => {
const serviceKey = Modules.SALES_CHANNEL
const loaded = await MedusaModule.bootstrap<ISalesChannelModuleService>({
moduleKey: serviceKey,
defaultPath: MODULE_PACKAGE_NAMES[Modules.SALES_CHANNEL],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[serviceKey]
}
@@ -1,37 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as SalesChannelModels from "@models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(
SalesChannelModels
) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.SALES_CHANNEL,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,13 +1,8 @@
import { ModuleExports } from "@medusajs/types"
import { SalesChannelModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
const service = SalesChannelModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
}
@@ -1 +0,0 @@
export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils"
@@ -1,11 +0,0 @@
import { asValue } from "awilix"
export const salesChannelRepositoryMock = {
salesChannelRepository: asValue({
find: jest.fn().mockImplementation(async ({ where: { code } }) => {
return [{}]
}),
findAndCount: jest.fn().mockResolvedValue([[], 0]),
getFreshManager: jest.fn().mockResolvedValue({}),
}),
}
@@ -0,0 +1 @@
it("noop", () => {})
@@ -1,47 +0,0 @@
import { createMedusaContainer } from "@medusajs/utils"
import { asValue } from "awilix"
import ContainerLoader from "../../loaders/container"
import { salesChannelRepositoryMock } from "../__fixtures__/sales-channel"
describe("Sales channel service", function () {
let container
beforeEach(async function () {
jest.clearAllMocks()
container = createMedusaContainer()
container.register("manager", asValue({}))
await ContainerLoader({ container })
container.register(salesChannelRepositoryMock)
})
it("should list sales channels with filters and relations", async function () {
const salesChannelRepository = container.resolve("salesChannelRepository")
const salesChannelService = container.resolve("salesChannelService")
const config = {
select: ["id", "name"],
}
await salesChannelService.list({}, config)
expect(salesChannelRepository.find).toHaveBeenCalledWith(
{
where: {},
options: {
fields: ["id", "name"],
limit: 15,
offset: 0,
orderBy: {
id: "ASC",
},
withDeleted: undefined,
populate: [],
},
},
expect.any(Object)
)
})
})
@@ -1,14 +1,6 @@
import { Modules, initializeFactory } from "@medusajs/modules-sdk"
import { moduleDefinition } from "./module-definition"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.STOCK_LOCATION,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,8 @@
import * as StockLocationModels from "@models"
import * as StockLocationRepostiories from "@repositories"
import * as StockLocationServices from "@services"
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { StockLocationModuleService } from "@services"
const migrationScriptOptions = {
moduleName: Modules.STOCK_LOCATION,
models: StockLocationModels,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: StockLocationModels,
moduleRepositories: StockLocationRepostiories,
moduleServices: StockLocationServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.STOCK_LOCATION,
moduleModels: Object.values(StockLocationModels),
migrationsPath: __dirname + "/migrations",
})
import { ModuleExports } from "@medusajs/types"
const service = StockLocationModuleService
const loaders = [containerLoader, connectionLoader]
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
-7
View File
@@ -1,14 +1,7 @@
import { moduleDefinition } from "./module-definition"
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
export * from "./types"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.STORE,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
@@ -1,44 +1,8 @@
import { ModuleExports } from "@medusajs/types"
import * as ModuleServices from "@services"
import { StoreModuleService } from "@services"
import { Modules } from "@medusajs/modules-sdk"
import * as Models from "@models"
import * as ModuleModels from "@models"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleRepositories from "@repositories"
const migrationScriptOptions = {
moduleName: Modules.STORE,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.STORE,
moduleModels: Object.values(Models),
migrationsPath: __dirname + "/migrations",
})
const service = StoreModuleService
const loaders = [containerLoader, connectionLoader] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
-7
View File
@@ -1,13 +1,6 @@
import { initializeFactory, Modules } from "@medusajs/modules-sdk"
import { moduleDefinition } from "./module-definition"
export * from "./models"
export * from "./services"
export const initialize = initializeFactory({
moduleName: Modules.TAX,
moduleDefinition,
})
export const runMigrations = moduleDefinition.runMigrations
export const revertMigration = moduleDefinition.revertMigration
export default moduleDefinition
+1 -34
View File
@@ -1,44 +1,11 @@
import { MikroOrmBaseRepository, ModulesSdkUtils } from "@medusajs/utils"
import { Modules } from "@medusajs/modules-sdk"
import { ModuleExports } from "@medusajs/types"
import * as Models from "@models"
import * as ModuleModels from "@models"
import * as ModuleServices from "@services"
import { TaxModuleService } from "@services"
import loadProviders from "./loaders/providers"
const migrationScriptOptions = {
moduleName: Modules.TAX,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const containerLoader = ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: { BaseRepository: MikroOrmBaseRepository },
moduleServices: ModuleServices,
})
const connectionLoader = ModulesSdkUtils.mikroOrmConnectionLoaderFactory({
moduleName: Modules.TAX,
moduleModels: Object.values(Models),
migrationsPath: __dirname + "/migrations",
})
const service = TaxModuleService
const loaders = [containerLoader, connectionLoader, loadProviders] as any
const loaders = [loadProviders]
export const moduleDefinition: ModuleExports = {
service,
loaders,
revertMigration,
runMigrations,
}
+1 -9
View File
@@ -1,11 +1,3 @@
import {
moduleDefinition,
revertMigration,
runMigrations,
} from "./module-definition"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
export { revertMigration, runMigrations }
export * from "./initialize"
export * from "./loaders"
@@ -1,31 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MODULE_PACKAGE_NAMES,
MedusaModule,
Modules,
} from "@medusajs/modules-sdk"
import { IUserModuleService, ModulesSdkTypes } from "@medusajs/types"
import { InitializeModuleInjectableDependencies } from "../types"
import { moduleDefinition } from "../module-definition"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleBootstrapDeclaration
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IUserModuleService> => {
const loaded = await MedusaModule.bootstrap<IUserModuleService>({
moduleKey: Modules.USER,
defaultPath: MODULE_PACKAGE_NAMES[Modules.USER],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.USER]
}
@@ -1,36 +0,0 @@
import * as UserModels from "../models"
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { EntitySchema } from "@mikro-orm/core"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(UserModels) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.USER,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,10 +0,0 @@
import { ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleRepositories from "@repositories"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleRepositories: ModuleRepositories,
moduleServices: ModuleServices,
})
@@ -1,2 +0,0 @@
export * from "./connection"
export * from "./container"
@@ -1,31 +1,8 @@
import * as Models from "@models"
import { UserModuleService } from "@services"
import { ModuleExports } from "@medusajs/types"
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
const migrationScriptOptions = {
moduleName: Modules.USER,
models: Models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
const service = UserModuleService
const loaders = [loadContainer, loadConnection] as any
export const moduleDefinition: ModuleExports = {
service,
loaders,
runMigrations,
revertMigration,
}
@@ -1,22 +1,5 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as models from "@models"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
const migrationScriptOptions = {
moduleName: Modules.WORKFLOW_ENGINE,
models: models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
export * from "./initialize"
export * from "./loaders"
@@ -1,34 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MODULE_PACKAGE_NAMES,
MedusaModule,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { IWorkflowEngineService } from "@medusajs/workflows-sdk"
import { moduleDefinition } from "../module-definition"
import { InitializeModuleInjectableDependencies } from "../types"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IWorkflowEngineService> => {
const loaded =
// eslint-disable-next-line max-len
await MedusaModule.bootstrap<IWorkflowEngineService>({
moduleKey: Modules.WORKFLOW_ENGINE,
defaultPath: MODULE_PACKAGE_NAMES[Modules.WORKFLOW_ENGINE],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.WORKFLOW_ENGINE]
}
@@ -1,36 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as WorkflowOrchestratorModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(
WorkflowOrchestratorModels
) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.WORKFLOW_ENGINE,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,9 +0,0 @@
import { MikroOrmBaseRepository, ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleServices: ModuleServices,
moduleRepositories: { BaseRepository: MikroOrmBaseRepository },
})
@@ -1,3 +1 @@
export * from "./connection"
export * from "./container"
export * from "./utils"
@@ -1,11 +1,9 @@
import { ModuleExports } from "@medusajs/types"
import { WorkflowsModuleService } from "@services"
import loadConnection from "./loaders/connection"
import loadContainer from "./loaders/container"
import loadUtils from "./loaders/utils"
const service = WorkflowsModuleService
const loaders = [loadContainer, loadConnection, loadUtils] as any
const loaders = [loadUtils]
export const moduleDefinition: ModuleExports = {
service,
@@ -1,22 +1,5 @@
import { Modules } from "@medusajs/modules-sdk"
import { ModulesSdkUtils } from "@medusajs/utils"
import * as models from "@models"
import { moduleDefinition } from "./module-definition"
export default moduleDefinition
const migrationScriptOptions = {
moduleName: Modules.WORKFLOW_ENGINE,
models: models,
pathToMigrations: __dirname + "/migrations",
}
export const runMigrations = ModulesSdkUtils.buildMigrationScript(
migrationScriptOptions
)
export const revertMigration = ModulesSdkUtils.buildRevertMigrationScript(
migrationScriptOptions
)
export * from "./initialize"
export * from "./loaders"
@@ -1,35 +0,0 @@
import {
ExternalModuleDeclaration,
InternalModuleDeclaration,
MODULE_PACKAGE_NAMES,
MedusaModule,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { IWorkflowEngineService } from "@medusajs/workflows-sdk"
import { moduleDefinition } from "../module-definition"
import { InitializeModuleInjectableDependencies } from "../types"
export const initialize = async (
options?:
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
| ExternalModuleDeclaration
| InternalModuleDeclaration,
injectedDependencies?: InitializeModuleInjectableDependencies
): Promise<IWorkflowEngineService> => {
const loaded =
// eslint-disable-next-line max-len
await MedusaModule.bootstrap<IWorkflowEngineService>({
moduleKey: Modules.WORKFLOW_ENGINE,
defaultPath: MODULE_PACKAGE_NAMES[Modules.WORKFLOW_ENGINE],
declaration: options as
| InternalModuleDeclaration
| ExternalModuleDeclaration,
injectedDependencies,
moduleExports: moduleDefinition,
})
return loaded[Modules.WORKFLOW_ENGINE]
}
@@ -1,36 +0,0 @@
import {
InternalModuleDeclaration,
LoaderOptions,
Modules,
} from "@medusajs/modules-sdk"
import { ModulesSdkTypes } from "@medusajs/types"
import { ModulesSdkUtils } from "@medusajs/utils"
import { EntitySchema } from "@mikro-orm/core"
import * as WorkflowOrchestratorModels from "../models"
export default async (
{
options,
container,
logger,
}: LoaderOptions<
| ModulesSdkTypes.ModuleServiceInitializeOptions
| ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions
>,
moduleDeclaration?: InternalModuleDeclaration
): Promise<void> => {
const entities = Object.values(
WorkflowOrchestratorModels
) as unknown as EntitySchema[]
const pathToMigrations = __dirname + "/../migrations"
await ModulesSdkUtils.mikroOrmConnectionLoader({
moduleName: Modules.WORKFLOW_ENGINE,
entities,
container,
options,
moduleDeclaration,
logger,
pathToMigrations,
})
}
@@ -1,9 +0,0 @@
import { MikroOrmBaseRepository, ModulesSdkUtils } from "@medusajs/utils"
import * as ModuleModels from "@models"
import * as ModuleServices from "@services"
export default ModulesSdkUtils.moduleContainerLoaderFactory({
moduleModels: ModuleModels,
moduleServices: ModuleServices,
moduleRepositories: { BaseRepository: MikroOrmBaseRepository },
})

Some files were not shown because too many files have changed in this diff Show More