/** * 数据源管理器实现 */ import { extend } from '../util/extend'; import { MidwayCommonError, MidwayParameterError } from '../error'; import { run } from '@midwayjs/glob'; import { join, parse } from 'path'; import { Types } from '../util/types'; import { DEFAULT_PATTERN, IGNORE_PATTERN } from '../constants'; import { debuglog } from 'util'; import { loadModule } from '../util'; import { ModuleLoadType, DataSourceManagerConfigOption, IDataSourceManager, BaseDataSourceManagerConfigOption, } from '../interface'; import { Inject } from '../decorator'; import { MidwayEnvironmentService } from '../service/environmentService'; import { MidwayPriorityManager } from './priorityManager'; const debug = debuglog('midway:debug'); export abstract class DataSourceManager< T, ConnectionOpts extends BaseDataSourceManagerConfigOption< Record, ENTITY_CONFIG_KEY > = BaseDataSourceManagerConfigOption, 'entities'>, ENTITY_CONFIG_KEY extends string = 'entities', > implements IDataSourceManager { protected dataSource: Map = new Map(); protected options: DataSourceManagerConfigOption< ConnectionOpts, ENTITY_CONFIG_KEY > = {}; protected modelMapping = new WeakMap(); private innerDefaultDataSourceName: string; protected dataSourcePriority: Record = {}; // for multi client with initialization private creatingDataSources = new Map>(); @Inject() protected baseDir: string; @Inject() protected environmentService: MidwayEnvironmentService; @Inject() protected priorityManager: MidwayPriorityManager; protected async initDataSource( dataSourceConfig: DataSourceManagerConfigOption< ConnectionOpts, ENTITY_CONFIG_KEY >, baseDirOrOptions: | { baseDir?: string; entitiesConfigKey?: string; concurrent?: boolean; } | string ): Promise { this.options = dataSourceConfig; if (!this.options.dataSource) { throw new MidwayParameterError( '[DataSourceManager] must set options.dataSource.' ); } if (typeof baseDirOrOptions === 'string') { baseDirOrOptions = { baseDir: baseDirOrOptions, entitiesConfigKey: 'entities', concurrent: false, }; } const { baseDir = this.baseDir, entitiesConfigKey = 'entities', concurrent, } = baseDirOrOptions; const processDataSource = async ( dataSourceName: string, dataSourceOptions: any ) => { const userEntities = dataSourceOptions[entitiesConfigKey] as any[]; if (userEntities) { const entities = new Set(); const processEntity = async (entity: any) => { if (typeof entity === 'string') { // string will be glob file const models = await DataSourceManager.globModels( entity, baseDir, this.environmentService?.getModuleLoadType() ); for (const model of models) { entities.add(model); this.modelMapping.set(model, dataSourceName); } } else { // model will be added to array entities.add(entity); this.modelMapping.set(entity, dataSourceName); } }; if (concurrent) { await Promise.all(userEntities.map(processEntity)); } else { for (const entity of userEntities) { await processEntity(entity); } } dataSourceOptions[entitiesConfigKey] = Array.from(entities); debug( `[core]: DataManager load ${dataSourceOptions[entitiesConfigKey].length} models from ${dataSourceName}.` ); } // create data source const opts = { cacheInstance: dataSourceConfig.cacheInstance, validateConnection: dataSourceConfig.validateConnection, }; return this.createInstance(dataSourceOptions, dataSourceName, opts); }; const entries = Object.entries(dataSourceConfig.dataSource); if (concurrent) { await Promise.all( entries.map(([name, options]) => processDataSource(name, options)) ); } else { for (const [name, options] of entries) { await processDataSource(name, options); } } } /** * get a data source instance * @param dataSourceName */ public getDataSource(dataSourceName: string) { return this.dataSource.get(dataSourceName); } /** * check data source has exists * @param dataSourceName */ public hasDataSource(dataSourceName: string): boolean { return this.dataSource.has(dataSourceName); } public getDataSourceNames() { return Array.from(this.dataSource.keys()); } public getAllDataSources() { return this.dataSource; } /** * check the data source is connected * @param dataSourceName */ public async isConnected(dataSourceName: string): Promise { const inst = this.getDataSource(dataSourceName); return inst ? this.checkConnected(inst) : false; } public async createInstance(config: ConnectionOpts): Promise; public async createInstance( config: ConnectionOpts, clientName: string, options?: { /** * @deprecated */ validateConnection?: boolean; /** * @deprecated */ cacheInstance?: boolean | undefined; } ): Promise; public async createInstance( config: ConnectionOpts, clientName?: any, options?: { validateConnection?: boolean; cacheInstance?: boolean | undefined; } ): Promise { if (clientName && typeof clientName !== 'string') { options = clientName; clientName = undefined; } if (clientName && options && options.cacheInstance === false) { // 后面就用传不传 clientName 来判断是否缓存 clientName = undefined; } if (clientName) { if (this.dataSource.has(clientName)) { return this.dataSource.get(clientName); } if (this.creatingDataSources.has(clientName)) { return this.creatingDataSources.get(clientName); } } const validateConnection = config.validateConnection ?? (options && options.validateConnection) ?? false; // options.clients[id] will be merged with options.default const configNow = extend(true, {}, this.options['default'], config); const clientCreatingPromise = this.createDataSource(configNow, clientName); if (clientCreatingPromise && Types.isPromise(clientCreatingPromise)) { if (clientName) { this.creatingDataSources.set( clientName, clientCreatingPromise as Promise ); } return (clientCreatingPromise as Promise) .then(async client => { if (clientName) { this.dataSource.set(clientName, client); } if (validateConnection) { if (!client) { throw new MidwayCommonError( `[DataSourceManager] ${clientName} initialization failed.` ); } const connected = await this.checkConnected(client); if (!connected) { throw new MidwayCommonError( `[DataSourceManager] ${clientName} is not connected.` ); } } return client; }) .finally(() => { if (clientName) { this.creatingDataSources.delete(clientName); } }); } // 处理同步返回的情况 if (clientName) { this.dataSource.set(clientName, clientCreatingPromise as T); } return clientCreatingPromise; } /** * get data source name by model or repository * @param modelOrRepository */ public getDataSourceNameByModel(modelOrRepository: any): string | undefined { return this.modelMapping.get(modelOrRepository); } public abstract getName(): string; protected abstract createDataSource( config, dataSourceName: string ): Promise | (T | void); protected abstract checkConnected(dataSource: T): Promise; protected abstract destroyDataSource(dataSource: T): Promise; /** * Call destroyDataSource() on all data sources */ public async stop(): Promise { const arr = Array.from(this.dataSource.values()); await Promise.all( arr.map(dbh => { return this.destroyDataSource(dbh); }) ); this.dataSource.clear(); } public getDefaultDataSourceName(): string { if (this.innerDefaultDataSourceName === undefined) { if (this.options['defaultDataSourceName']) { this.innerDefaultDataSourceName = this.options['defaultDataSourceName']; } else if (this.dataSource.size === 1) { // Set the default source name when there is only one data source this.innerDefaultDataSourceName = Array.from(this.dataSource.keys())[0]; } else { // Set empty string for cache this.innerDefaultDataSourceName = ''; } } return this.innerDefaultDataSourceName; } public getDataSourcePriority(name: string) { return this.priorityManager.getPriority(this.dataSourcePriority[name]); } public isHighPriority(name: string) { return this.priorityManager.isHighPriority(this.dataSourcePriority[name]); } public isMediumPriority(name: string) { return this.priorityManager.isMediumPriority(this.dataSourcePriority[name]); } public isLowPriority(name: string) { return this.priorityManager.isLowPriority(this.dataSourcePriority[name]); } static formatGlobString(globString: string): string[] { let pattern; if (!/^\*/.test(globString)) { globString = '/' + globString; } const parsePattern = parse(globString); if ( parsePattern.base && (/\*/.test(parsePattern.base) || parsePattern.ext) ) { pattern = [globString]; } else { pattern = [...DEFAULT_PATTERN.map(p => join(globString, p))]; } return pattern; } static async globModels( globString: string, baseDir: string, loadMode?: ModuleLoadType ) { const pattern = this.formatGlobString(globString); const models = []; // string will be glob file const files = run(pattern, { cwd: baseDir, ignore: IGNORE_PATTERN, }); for (const file of files) { const exports = await loadModule(file, { loadMode, }); if (Types.isClass(exports)) { models.push(exports); } else { for (const m in exports) { const module = exports[m]; if (Types.isClass(module)) { models.push(module); } } } } return models; } }