asyavee/medusa-store
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Feat(medusa,modules-sdk): Modules SDK package (#3294)

Browse Source
This commit is contained in:
Carlos R. L. Rodrigues
2023-02-23 13:09:35 -03:00
committed by GitHub
parent f3bf351d21
commit ad7f56506f
37 changed files with 317 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/medusa/package.json
+1
View File
@@ -49,6 +49,7 @@
},
"dependencies": {
"@medusajs/medusa-cli": "^1.3.8",
"@medusajs/modules-sdk": "*",
"@types/ioredis": "^4.28.10",
"@types/lodash": "^4.14.191",
"awilix": "^8.0.0",
packages/medusa/src/api/routes/admin/store/get-store.ts
+1 -1
View File
@@ -5,7 +5,7 @@ import {
} from "../../../../services"
import { ExtendedStoreDTO } from "../../../../types/store"
import { FlagRouter } from "../../../../utils/flag-router"
import { ModulesHelper } from "../../../../utils/module-helper"
import { ModulesHelper } from "@medusajs/modules-sdk"
/**
* @oas [get] /admin/store
packages/medusa/src/commands/utils/get-migrations.js
+2 -2
View File
@@ -5,7 +5,7 @@ import { isString } from "lodash"
import { sync as existsSync } from "fs-exists-cached"
import { getConfigFile, createRequireFromPath } from "medusa-core-utils"
import { handleConfigError } from "../../loaders/config"
import registerModuleDefinitions from "../../loaders/module-definitions"
import { registerModules } from "@medusajs/modules-sdk"
function createFileContentHash(path, files) {
return path + files
@@ -92,7 +92,7 @@ function resolvePlugin(pluginName) {
export function getInternalModules(configModule) {
const modules = []
const moduleResolutions = registerModuleDefinitions(configModule)
const moduleResolutions = registerModules(configModule)
for (const moduleResolution of Object.values(moduleResolutions)) {
if (
packages/medusa/src/helpers/test-request.js
+6 -4
View File
@@ -7,12 +7,14 @@ import "reflect-metadata"
import supertest from "supertest"
import apiLoader from "../loaders/api"
import featureFlagLoader, { featureFlagRouter } from "../loaders/feature-flags"
import { moduleHelper } from "../loaders/module"
import {
moduleLoader,
moduleHelper,
registerModules,
} from "@medusajs/modules-sdk"
import passportLoader from "../loaders/passport"
import servicesLoader from "../loaders/services"
import strategiesLoader from "../loaders/strategies"
import registerModuleDefinitions from "../loaders/module-definitions"
import moduleLoader from "../loaders/module"
const adminSessionOpts = {
cookieName: "session",
@@ -26,7 +28,7 @@ const clientSessionOpts = {
secret: "test",
}
const moduleResolutions = registerModuleDefinitions({})
const moduleResolutions = registerModules({})
const config = {
projectConfig: {
jwt_secret: "supersecret",
packages/medusa/src/loaders/__mocks__/@modules/brokenloader.ts
-13
View File
@@ -1,13 +0,0 @@
const loader = ({}) => {
throw new Error("loader")
}
const service = class TestService {}
const migrations = []
const loaders = [loader]
export default {
service,
migrations,
loaders,
}
packages/medusa/src/loaders/__mocks__/@modules/default.ts
-11
View File
@@ -1,11 +0,0 @@
const service = class TestService {}
const migrations = []
const loaders = []
const models = []
export default {
service,
migrations,
loaders,
models,
}
packages/medusa/src/loaders/__mocks__/@modules/no-service.ts
-7
View File
@@ -1,7 +0,0 @@
const migrations = []
const loaders = []
export default {
migrations,
loaders,
}
packages/medusa/src/loaders/__mocks__/medusa-telemetry.ts
-2
View File
@@ -1,2 +0,0 @@
export const trackInstallation = jest.fn()
export const trackFeatureFlag = jest.fn()
packages/medusa/src/loaders/__tests__/module-definitions.spec.ts
-202
View File
@@ -1,202 +0,0 @@
import {
ConfigModule,
ModuleDefinition,
MODULE_RESOURCE_TYPE,
MODULE_SCOPE,
} from "../../types/global"
import ModuleDefinitionLoader from "../module-definitions"
import MODULE_DEFINITIONS from "../module-definitions/definitions"
const RESOLVED_PACKAGE = "@medusajs/test-service-resolved"
jest.mock("resolve-cwd", () => jest.fn(() => RESOLVED_PACKAGE))
describe("module definitions loader", () => {
const defaultDefinition: ModuleDefinition = {
key: "testService",
registrationName: "testService",
defaultPackage: "@medusajs/test-service",
label: "TestService",
isRequired: false,
canOverride: true,
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
}
beforeEach(() => {
jest.resetModules()
jest.clearAllMocks()
// Clear module definitions
MODULE_DEFINITIONS.splice(0, MODULE_DEFINITIONS.length)
})
it("Resolves module with default definition given empty config", () => {
MODULE_DEFINITIONS.push({ ...defaultDefinition })
const res = ModuleDefinitionLoader({ modules: {} } as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: defaultDefinition.defaultPackage,
definition: defaultDefinition,
options: {},
moduleDeclaration: {
scope: "internal",
resources: "shared",
},
})
})
describe("boolean config", () => {
it("Resolves module with no resolution path when given false", () => {
MODULE_DEFINITIONS.push({ ...defaultDefinition })
const res = ModuleDefinitionLoader({
modules: { [defaultDefinition.key]: false },
} as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: false,
definition: defaultDefinition,
options: {},
})
})
it("Fails to resolve module with no resolution path when given false for a required module", () => {
expect.assertions(1)
MODULE_DEFINITIONS.push({ ...defaultDefinition, isRequired: true })
try {
ModuleDefinitionLoader({
modules: { [defaultDefinition.key]: false },
} as ConfigModule)
} catch (err) {
expect(err.message).toEqual(
`Module: ${defaultDefinition.label} is required`
)
}
})
it("Resolves module with no resolution path when not given custom resolution path as false as default package", () => {
const definition = {
...defaultDefinition,
defaultPackage: false as false,
}
MODULE_DEFINITIONS.push(definition)
const res = ModuleDefinitionLoader({
modules: {},
} as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: false,
definition: definition,
options: {},
moduleDeclaration: {
scope: "internal",
resources: "shared",
},
})
})
})
describe("string config", () => {
it("Resolves module with default definition given empty config", () => {
MODULE_DEFINITIONS.push({ ...defaultDefinition })
const res = ModuleDefinitionLoader({
modules: {
[defaultDefinition.key]: defaultDefinition.defaultPackage,
},
} as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: RESOLVED_PACKAGE,
definition: defaultDefinition,
options: {},
moduleDeclaration: {
scope: "internal",
resources: "shared",
},
})
})
})
describe("object config", () => {
it("Resolves resolution path and provides empty options when none are provided", () => {
MODULE_DEFINITIONS.push({ ...defaultDefinition })
const res = ModuleDefinitionLoader({
modules: {
[defaultDefinition.key]: {
resolve: defaultDefinition.defaultPackage,
resources: MODULE_RESOURCE_TYPE.ISOLATED,
},
},
} as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: RESOLVED_PACKAGE,
definition: defaultDefinition,
options: {},
moduleDeclaration: {
scope: "internal",
resources: "isolated",
resolve: defaultDefinition.defaultPackage,
},
})
})
it("Resolves default resolution path and provides options when only options are provided", () => {
MODULE_DEFINITIONS.push({ ...defaultDefinition })
const res = ModuleDefinitionLoader({
modules: {
[defaultDefinition.key]: {
options: { test: 123 },
},
},
} as unknown as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: defaultDefinition.defaultPackage,
definition: defaultDefinition,
options: { test: 123 },
moduleDeclaration: {
scope: "internal",
resources: "shared",
options: { test: 123 },
},
})
})
it("Resolves resolution path and provides options when only options are provided", () => {
MODULE_DEFINITIONS.push({ ...defaultDefinition })
const res = ModuleDefinitionLoader({
modules: {
[defaultDefinition.key]: {
resolve: defaultDefinition.defaultPackage,
options: { test: 123 },
scope: "internal",
resources: "isolated",
},
},
} as unknown as ConfigModule)
expect(res[defaultDefinition.key]).toEqual({
resolutionPath: RESOLVED_PACKAGE,
definition: defaultDefinition,
options: { test: 123 },
moduleDeclaration: {
scope: "internal",
resources: "isolated",
resolve: defaultDefinition.defaultPackage,
options: { test: 123 },
},
})
})
})
})
packages/medusa/src/loaders/__tests__/module.spec.ts
-335
View File
@@ -1,335 +0,0 @@
import {
asFunction,
asValue,
AwilixContainer,
ClassOrFunctionReturning,
createContainer,
Resolver
} from "awilix"
import {
ConfigModule,
MedusaContainer,
ModuleResolution,
MODULE_RESOURCE_TYPE,
MODULE_SCOPE
} from "../../types/global"
import Logger from "../logger"
import registerModules from "../module"
import { trackInstallation } from "../__mocks__/medusa-telemetry"
function asArray(
resolvers: (ClassOrFunctionReturning<unknown> | Resolver<unknown>)[]
): { resolve: (container: AwilixContainer) => unknown[] } {
return {
resolve: (container: AwilixContainer): unknown[] =>
resolvers.map((resolver) => container.build(resolver)),
}
}
const buildConfigModule = (
configParts: Partial<ConfigModule>
): ConfigModule => {
return {
projectConfig: {
database_type: "sqlite",
database_logging: "all",
},
featureFlags: {},
modules: {},
moduleResolutions: {},
plugins: [],
...configParts,
}
}
const buildContainer = () => {
const container = createContainer() as MedusaContainer
container.registerAdd = function (
this: MedusaContainer,
name: string,
registration: typeof asFunction | typeof asValue
): MedusaContainer {
const storeKey = name + "_STORE"
if (this.registrations[storeKey] === undefined) {
this.register(storeKey, asValue([] as Resolver<unknown>[]))
}
const store = this.resolve(storeKey) as (
| ClassOrFunctionReturning<unknown>
| Resolver<unknown>
)[]
if (this.registrations[name] === undefined) {
this.register(name, asArray(store))
}
store.unshift(registration)
return this
}.bind(container)
return container
}
describe("modules loader", () => {
let container
afterEach(() => {
jest.clearAllMocks()
})
beforeEach(() => {
container = buildContainer()
})
it("registers service as undefined in container when no resolution path is given", async () => {
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: false,
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
moduleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
}
const configModule = buildConfigModule({
moduleResolutions,
})
await registerModules({ container, configModule, logger: Logger })
const testService = container.resolve(
moduleResolutions.testService.definition.key
)
expect(testService).toBe(undefined)
})
it("registers service ", async () => {
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: "@modules/default",
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
moduleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
}
const configModule = buildConfigModule({
moduleResolutions,
})
await registerModules({ container, configModule, logger: Logger })
const testService = container.resolve(
moduleResolutions.testService.definition.key,
{}
)
expect(trackInstallation).toHaveBeenCalledWith(
{
module: moduleResolutions.testService.definition.key,
resolution: moduleResolutions.testService.resolutionPath,
},
"module"
)
expect(testService).toBeTruthy()
expect(typeof testService).toEqual("object")
})
it("runs defined loaders and logs error", async () => {
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: "@modules/brokenloader",
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
moduleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
}
const logger: typeof Logger = {
warn: jest.fn(),
}
const configModule = buildConfigModule({
moduleResolutions,
})
await registerModules({ container, configModule, logger })
expect(logger.warn).toHaveBeenCalledWith(
"Could not resolve module: TestService. Error: Loaders for module TestService failed: loader"
)
})
it("logs error if no service is defined", async () => {
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: "@modules/no-service",
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
moduleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
}
const logger: typeof Logger = {
warn: jest.fn(),
}
const configModule = buildConfigModule({
moduleResolutions,
})
await registerModules({ container, configModule, logger })
expect(logger.warn).toHaveBeenCalledWith(
"Could not resolve module: TestService. Error: No service found in module. Make sure that your module exports a service."
)
})
it("throws error if no service is defined and module is required", async () => {
expect.assertions(1)
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: "@modules/no-service",
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
isRequired: true,
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
moduleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
}
const configModule = buildConfigModule({
moduleResolutions,
})
try {
await registerModules({ container, configModule, logger: Logger })
} catch (err) {
expect(err.message).toEqual(
"No service found in module. Make sure that your module exports a service."
)
}
})
it("throws error if no scope is defined to the module", async () => {
expect.assertions(1)
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: "@modules/no-service",
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
isRequired: true,
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
// @ts-ignore
moduleDeclaration: {
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
}
const configModule = buildConfigModule({
moduleResolutions,
})
try {
await registerModules({ container, configModule, logger: Logger })
} catch (err) {
expect(err.message).toEqual(
"The module TestService has to define its scope (internal | external)"
)
}
})
it("throws error if resources is not set when scope is defined as internal", async () => {
expect.assertions(1)
const moduleResolutions: Record<string, ModuleResolution> = {
testService: {
resolutionPath: "@modules/no-service",
definition: {
registrationName: "testService",
key: "testService",
defaultPackage: "testService",
label: "TestService",
isRequired: true,
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
// @ts-ignore
moduleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
},
},
}
const configModule = buildConfigModule({
moduleResolutions,
})
try {
await registerModules({ container, configModule, logger: Logger })
} catch (err) {
expect(err.message).toEqual(
"The module TestService is missing its resources config"
)
}
})
})
packages/medusa/src/loaders/config.ts
+2 -2
View File
@@ -1,7 +1,7 @@
import { getConfigFile } from "medusa-core-utils"
import { ConfigModule } from "../types/global"
import logger from "./logger"
import registerModuleDefinitions from "./module-definitions"
import { registerModules } from "@medusajs/modules-sdk"
const isProduction = ["production", "prod"].includes(process.env.NODE_ENV || "")
@@ -65,7 +65,7 @@ export default (rootDirectory: string): ConfigModule => {
)
}
const moduleResolutions = registerModuleDefinitions(configModule)
const moduleResolutions = registerModules(configModule)
return {
projectConfig: {
packages/medusa/src/loaders/index.ts
+2 -1
View File
@@ -21,7 +21,6 @@ import expressLoader from "./express"
import featureFlagsLoader from "./feature-flags"
import Logger from "./logger"
import modelsLoader from "./models"
import moduleLoader from "./module"
import passportLoader from "./passport"
import pluginsLoader, { registerPluginModels } from "./plugins"
import redisLoader from "./redis"
@@ -31,6 +30,8 @@ import servicesLoader from "./services"
import strategiesLoader from "./strategies"
import subscribersLoader from "./subscribers"
import { moduleLoader } from "@medusajs/modules-sdk"
type Options = {
directory: string
expressApp: Express
packages/medusa/src/loaders/module-definitions/definitions.ts
-34
View File
@@ -1,34 +0,0 @@
import {
ModuleDefinition,
MODULE_RESOURCE_TYPE,
MODULE_SCOPE,
} from "../../types/global"
export const MODULE_DEFINITIONS: ModuleDefinition[] = [
{
key: "stockLocationService",
registrationName: "stockLocationService",
defaultPackage: false,
label: "StockLocationService",
isRequired: false,
canOverride: true,
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
{
key: "inventoryService",
registrationName: "inventoryService",
defaultPackage: false,
label: "InventoryService",
isRequired: false,
canOverride: true,
defaultModuleDeclaration: {
scope: MODULE_SCOPE.INTERNAL,
resources: MODULE_RESOURCE_TYPE.SHARED,
},
},
]
export default MODULE_DEFINITIONS
packages/medusa/src/loaders/module-definitions/index.ts
-61
View File
@@ -1,61 +0,0 @@
import resolveCwd from "resolve-cwd"
import { ConfigModule, ModuleResolution } from "../../types/global"
import MODULE_DEFINITIONS from "./definitions"
export default ({ modules }: ConfigModule) => {
const moduleResolutions = {} as Record<string, ModuleResolution>
const projectModules = modules ?? {}
for (const definition of MODULE_DEFINITIONS) {
let resolutionPath = definition.defaultPackage
const moduleConfiguration = projectModules[definition.key]
if (typeof moduleConfiguration === "boolean") {
if (!moduleConfiguration && definition.isRequired) {
throw new Error(`Module: ${definition.label} is required`)
}
if (!moduleConfiguration) {
moduleResolutions[definition.key] = {
resolutionPath: false,
definition,
options: {},
}
continue
}
}
// If user added a module and it's overridable, we resolve that instead
if (
definition.canOverride &&
(typeof moduleConfiguration === "string" ||
(typeof moduleConfiguration === "object" &&
moduleConfiguration.resolve))
) {
resolutionPath = resolveCwd(
typeof moduleConfiguration === "string"
? moduleConfiguration
: (moduleConfiguration.resolve as string)
)
}
const moduleDeclaration =
typeof moduleConfiguration === "object" ? moduleConfiguration : {}
moduleResolutions[definition.key] = {
resolutionPath,
definition,
moduleDeclaration: {
...definition.defaultModuleDeclaration,
...moduleDeclaration,
},
options:
typeof moduleConfiguration === "object"
? moduleConfiguration.options ?? {}
: {},
}
}
return moduleResolutions
}
packages/medusa/src/loaders/module.ts
-162
View File
@@ -1,162 +0,0 @@
import { asClass, asFunction, asValue } from "awilix"
import { trackInstallation } from "medusa-telemetry"
import { EntitySchema } from "typeorm"
import {
ClassConstructor,
ConfigModule,
LoaderOptions,
Logger,
MedusaContainer,
ModuleExports,
ModuleResolution,
MODULE_RESOURCE_TYPE,
MODULE_SCOPE,
} from "../types/global"
import { ModulesHelper } from "../utils/module-helper"
export const moduleHelper = new ModulesHelper()
const registerModule = async (
container: MedusaContainer,
resolution: ModuleResolution,
configModule: ConfigModule,
logger: Logger
): Promise<{ error?: Error } | void> => {
const constainerName = resolution.definition.registrationName
const { scope, resources } = resolution.moduleDeclaration ?? {}
if (!scope || (scope === MODULE_SCOPE.INTERNAL && !resources)) {
let message = `The module ${resolution.definition.label} has to define its scope (internal | external)`
if (scope && !resources) {
message = `The module ${resolution.definition.label} is missing its resources config`
}
container.register({
[constainerName]: asValue(undefined),
})
return {
error: new Error(message),
}
}
if (!resolution.resolutionPath) {
container.register({
[constainerName]: asValue(undefined),
})
return
}
let loadedModule: ModuleExports
try {
loadedModule = (await import(resolution.resolutionPath!)).default
} catch (error) {
return { error }
}
const moduleService = loadedModule?.service || null
if (!moduleService) {
return {
error: new Error(
"No service found in module. Make sure that your module exports a service."
),
}
}
if (
scope === MODULE_SCOPE.INTERNAL &&
resources === MODULE_RESOURCE_TYPE.SHARED
) {
const moduleModels = loadedModule?.models || null
if (moduleModels) {
moduleModels.map((val: ClassConstructor<unknown>) => {
container.registerAdd("db_entities", asValue(val))
})
}
}
// TODO: "cradle" should only contain dependent Modules and the EntityManager if module scope is shared
container.register({
[constainerName]: asFunction((cradle) => {
return new moduleService(
cradle,
resolution.options,
resolution.moduleDeclaration
)
}).singleton(),
})
const moduleLoaders = loadedModule?.loaders || []
try {
for (const loader of moduleLoaders) {
await loader(
{
container,
configModule,
logger,
options: resolution.options,
},
resolution.moduleDeclaration
)
}
} catch (err) {
return {
error: new Error(
`Loaders for module ${resolution.definition.label} failed: ${err.message}`
),
}
}
trackInstallation(
{
module: resolution.definition.key,
resolution: resolution.resolutionPath,
},
"module"
)
}
export default async ({
container,
configModule,
logger,
}: LoaderOptions): Promise<void> => {
const moduleResolutions = configModule?.moduleResolutions ?? {}
for (const resolution of Object.values(moduleResolutions)) {
const registrationResult = await registerModule(
container,
resolution,
configModule,
logger!
)
if (registrationResult?.error) {
const { error } = registrationResult
if (resolution.definition.isRequired) {
logger?.warn(
`Could not resolve required module: ${resolution.definition.label}. Error: ${error.message}`
)
throw error
}
logger?.warn(
`Could not resolve module: ${resolution.definition.label}. Error: ${error.message}`
)
}
}
moduleHelper.setModules(
Object.entries(moduleResolutions).reduce((acc, [k, v]) => {
if (v.resolutionPath) {
acc[k] = v
}
return acc
}, {})
)
container.register({
modulesHelper: asValue(moduleHelper),
})
}
packages/medusa/src/types/global.ts
+4 -61
View File
@@ -1,3 +1,7 @@
import {
ConfigurableModuleDeclaration,
ModuleResolution,
} from "@medusajs/modules-sdk"
import { AwilixContainer } from "awilix"
import { Request } from "express"
import { LoggerOptions } from "typeorm"
@@ -38,69 +42,8 @@ export type Logger = _Logger & {
warn: (msg: string) => void
}
export enum MODULE_SCOPE {
INTERNAL = "internal",
EXTERNAL = "external",
}
export enum MODULE_RESOURCE_TYPE {
SHARED = "shared",
ISOLATED = "isolated",
}
export type ConfigurableModuleDeclaration = {
scope: MODULE_SCOPE.INTERNAL
resources: MODULE_RESOURCE_TYPE
resolve?: string
options?: Record<string, unknown>
}
/*
| {
scope: MODULE_SCOPE.external
server: {
type: "built-in" | "rest" | "tsrpc" | "grpc" | "gql"
url: string
options?: Record<string, unknown>
}
}
*/
export type ModuleResolution = {
resolutionPath: string | false
definition: ModuleDefinition
options?: Record<string, unknown>
moduleDeclaration?: ConfigurableModuleDeclaration
}
export type ModuleDefinition = {
key: string
registrationName: string
defaultPackage: string | false
label: string
canOverride?: boolean
isRequired?: boolean
defaultModuleDeclaration: ConfigurableModuleDeclaration
}
export type LoaderOptions = {
container: MedusaContainer
configModule: ConfigModule
options?: Record<string, unknown>
logger?: Logger
}
export type Constructor<T> = new (...args: any[]) => T
export type ModuleExports = {
loaders: ((
options: LoaderOptions,
moduleDeclaration?: ConfigurableModuleDeclaration
) => Promise<void>)[]
service: Constructor<any>
migrations?: any[] // TODO: revisit migrations type
models?: Constructor<any>[]
}
type SessionOptions = {
name?: string
resave?: boolean
packages/medusa/src/types/modules.ts
-20
View File
@@ -1,20 +0,0 @@
/**
* @schema ModulesResponse
* type: array
* items:
* type: object
* required:
* - module
* - resolution
* properties:
* module:
* description: The key of the module.
* type: string
* resolution:
* description: The resolution path of the module or false if module is not installed.
* type: string
*/
export type ModulesResponse = {
module: string
resolution: string | false
}[]
packages/medusa/src/types/store.ts
+18 -1
View File
@@ -1,6 +1,6 @@
import { Store, PaymentProvider, FulfillmentProvider } from "../models"
import { FeatureFlagsResponse } from "./feature-flags"
import { ModulesResponse } from "./modules"
import { ModulesResponse } from "@medusajs/modules-sdk"
export type UpdateStoreInput = {
name?: string
@@ -13,6 +13,23 @@ export type UpdateStoreInput = {
default_sales_channel_id?: string
}
/**
* @schema ModulesResponse
* type: array
* items:
* type: object
* required:
* - module
* - resolution
* properties:
* module:
* description: The key of the module.
* type: string
* resolution:
* description: The resolution path of the module or false if module is not installed.
* type: string
*/
/**
* @schema ExtendedStoreDTO
* allOf:
packages/medusa/src/utils/module-helper.ts
-17
View File
@@ -1,17 +0,0 @@
import { ModuleResolution } from "../types/global"
import { ModulesResponse } from "../types/modules"
export class ModulesHelper {
private modules_: Record<string, ModuleResolution> = {}
setModules(modules: Record<string, ModuleResolution>) {
this.modules_ = modules
}
get modules(): ModulesResponse {
return Object.values(this.modules_ || {}).map((value) => ({
module: value.definition.key,
resolution: value.resolutionPath,
}))
}
}
packages/medusa/tsconfig.json
+3 -7
View File
@@ -1,10 +1,6 @@
{
"compilerOptions": {
"lib": [
"es5",
"es6",
"es2019"
],
"lib": ["es5", "es6", "es2019"],
"target": "es5",
"outDir": "./dist",
"esModuleInterop": true,
@@ -21,7 +17,7 @@
"allowJs": true,
"skipLibCheck": true,
"downlevelIteration": true, // to use ES5 specific tooling
"resolveJsonModule": true,
"resolveJsonModule": true
},
"include": ["./src/**/*", "index.d.ts"],
"exclude": [
@@ -31,4 +27,4 @@
"./src/**/__fixtures__",
"node_modules"
]
}
}