103 lines
4.3 KiB
JavaScript
103 lines
4.3 KiB
JavaScript
import { EntityManager, EntitySchema, MetadataStorage, MikroORM } from '@mikro-orm/core';
|
|
import { Scope } from '@nestjs/common';
|
|
import { MIKRO_ORM_MODULE_OPTIONS, getEntityManagerToken, getMikroORMToken, getRepositoryToken, logger, } from './mikro-orm.common.js';
|
|
import { MikroOrmEntitiesStorage } from './mikro-orm.entities.storage.js';
|
|
export function createMikroOrmProvider(contextName, type = MikroORM) {
|
|
if (!contextName && type !== MikroORM) {
|
|
return {
|
|
provide: type,
|
|
useFactory: orm => orm, // just a simple alias
|
|
inject: [MikroORM], // depend on the ORM from core package
|
|
};
|
|
}
|
|
return {
|
|
provide: contextName ? getMikroORMToken(contextName) : type,
|
|
useFactory: async (options) => {
|
|
options = { logger: logger.log.bind(logger), ...options };
|
|
if (options.autoLoadEntities) {
|
|
options.entities = [
|
|
...(options.entities || []),
|
|
...MikroOrmEntitiesStorage.getEntities(contextName),
|
|
];
|
|
options.entitiesTs = [
|
|
...(options.entitiesTs || []),
|
|
...MikroOrmEntitiesStorage.getEntities(contextName),
|
|
];
|
|
delete options.autoLoadEntities;
|
|
}
|
|
return MikroORM.init(options);
|
|
},
|
|
inject: [MIKRO_ORM_MODULE_OPTIONS],
|
|
};
|
|
}
|
|
export function createEntityManagerProvider(scope = Scope.DEFAULT, entityManager = EntityManager, contextName, forkOptions) {
|
|
if (!contextName && entityManager !== EntityManager) {
|
|
return {
|
|
provide: entityManager,
|
|
scope,
|
|
useFactory: (em) => em, // just a simple alias, unlike `useExisting` from nest, this works with request scopes too
|
|
inject: [EntityManager], // depend on the EM from core package
|
|
};
|
|
}
|
|
return {
|
|
provide: contextName ? getEntityManagerToken(contextName) : entityManager,
|
|
scope,
|
|
useFactory: (orm) => (scope === Scope.DEFAULT ? orm.em : orm.em.fork({ useContext: true, ...forkOptions })),
|
|
inject: [contextName ? getMikroORMToken(contextName) : MikroORM],
|
|
};
|
|
}
|
|
export function createMikroOrmAsyncOptionsProvider(options) {
|
|
if (options.useFactory) {
|
|
return {
|
|
provide: MIKRO_ORM_MODULE_OPTIONS,
|
|
useFactory: async (...args) => {
|
|
const factoryOptions = await options.useFactory(...args);
|
|
return options.contextName ? { contextName: options.contextName, ...factoryOptions } : factoryOptions;
|
|
},
|
|
inject: options.inject || [],
|
|
};
|
|
}
|
|
const inject = [];
|
|
if (options.useClass || options.useExisting) {
|
|
inject.push(options.useClass ?? options.useExisting);
|
|
}
|
|
return {
|
|
provide: MIKRO_ORM_MODULE_OPTIONS,
|
|
useFactory: async (optionsFactory) => await optionsFactory.createMikroOrmOptions(options.contextName),
|
|
inject,
|
|
};
|
|
}
|
|
export function createAsyncProviders(options) {
|
|
if (options.useExisting || options.useFactory) {
|
|
return [createMikroOrmAsyncOptionsProvider(options)];
|
|
}
|
|
if (options.useClass) {
|
|
return [createMikroOrmAsyncOptionsProvider(options), { provide: options.useClass, useClass: options.useClass }];
|
|
}
|
|
throw new Error('Invalid MikroORM async options: one of `useClass`, `useExisting` or `useFactory` should be defined.');
|
|
}
|
|
export function createMikroOrmRepositoryProviders(entities, contextName) {
|
|
const metadata = Object.values(MetadataStorage.getMetadata());
|
|
const providers = [];
|
|
const inject = contextName ? getEntityManagerToken(contextName) : EntityManager;
|
|
(entities || []).forEach(entity => {
|
|
const meta = entity instanceof EntitySchema
|
|
? entity.meta
|
|
: (typeof entity === 'function' ? EntitySchema.REGISTRY.get(entity)?.meta : undefined) ?? metadata.find(meta => meta.class === entity);
|
|
const repository = meta?.repository;
|
|
if (repository) {
|
|
providers.push({
|
|
provide: repository(),
|
|
useFactory: em => em.getRepository(entity),
|
|
inject: [inject],
|
|
});
|
|
}
|
|
providers.push({
|
|
provide: getRepositoryToken(entity, contextName),
|
|
useFactory: em => em.getRepository(entity),
|
|
inject: [inject],
|
|
});
|
|
});
|
|
return providers;
|
|
}
|