@midwayjs/core 3.20.4 → 4.0.0-beta.1

package/dist/context/dynamicContainer.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamicMidwayContainer = void 0;
+const container_1 = require("./container");
+const environmentService_1 = require("../service/environmentService");
+const util_1 = require("../util");
+const types_1 = require("../util/types");
+const decorator_1 = require("../decorator");
+const util_2 = require("util");
+const debug = (0, util_2.debuglog)('midway:container');
+/**
+ * 尝试用于开发时动态更新的 IoC 容器
+ */
+class DynamicMidwayContainer extends container_1.MidwayContainer {
+    constructor() {
+        super();
+        this.modifyClassMapping = new Map();
+        this.idRefMapping = new Map();
+        this.onBeforeBind((Clzz, options) => {
+            const definition = options.definition;
+            if (definition) {
+                if (definition.properties) {
+                    // 处理属性
+                    for (const propMetas of definition.properties.values()) {
+                        // 这里未处理懒加载依赖
+                        if (typeof propMetas.id === 'string') {
+                            if (this.idRefMapping.has(propMetas.id)) {
+                                this.idRefMapping.get(propMetas.id).push(definition.id);
+                            }
+                            else {
+                                this.idRefMapping.set(propMetas.id, [definition.id]);
+                            }
+                        }
+                    }
+                }
+                if (definition.constructorArgs) {
+                    // 处理构造器
+                    for (const constructMeta of definition.constructorArgs) {
+                        if (typeof constructMeta.id === 'string') {
+                            if (this.idRefMapping.has(constructMeta.id)) {
+                                this.idRefMapping.get(constructMeta.id).push(definition.id);
+                            }
+                            else {
+                                this.idRefMapping.set(constructMeta.id, [definition.id]);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    async updateDefinition(modifyFilePath) {
+        debug('updateDefinition %s', modifyFilePath);
+        if (!this.moduleType) {
+            const environmentService = await this.getAsync(environmentService_1.MidwayEnvironmentService);
+            this.moduleType = environmentService.getModuleLoadType();
+        }
+        // 根据文件路径找到老的类
+        const oldDefinitionList = this.findDefinitionByPath(modifyFilePath);
+        debug('oldDefinitionList size %s', oldDefinitionList.length);
+        if (!oldDefinitionList.length) {
+            return;
+        }
+        // 一个文件可能对应多个不同的 ObjectDefinition，但是导出的类名可能是不同的，所以可以使用类名作为 key
+        const nameList = {};
+        // 拿到旧的标识符
+        for (const oldDefinition of oldDefinitionList) {
+            nameList[oldDefinition.name] = oldDefinition.id;
+        }
+        debug('nameList %j', nameList);
+        // 清除 require cache
+        const requireCacheCleaned = this.findRequireCacheAndClear(modifyFilePath);
+        // 清理历史 context 缓存
+        for (const oldDefinition of oldDefinitionList) {
+            // 清理依赖的缓存
+            if (this.idRefMapping.has(oldDefinition.id)) {
+                for (const refId of this.idRefMapping.get(oldDefinition.id)) {
+                    if (this.hasObject(refId)) {
+                        this.removeObject(refId);
+                    }
+                }
+            }
+            else if (this.idRefMapping.has(oldDefinition.name)) {
+                for (const refId of this.idRefMapping.get(oldDefinition.name)) {
+                    if (this.hasObject(refId)) {
+                        this.removeObject(refId);
+                    }
+                }
+            }
+            // 清理自身
+            this.removeObject(oldDefinition.id);
+        }
+        debug('ready to load module %s', modifyFilePath);
+        // 重新加载新的文件
+        const modLoaded = await (0, util_1.loadModule)(modifyFilePath, {
+            loadMode: this.moduleType,
+        });
+        const newClassList = [];
+        if (types_1.Types.isClass(modLoaded) || types_1.Types.isFunction(modLoaded)) {
+            newClassList.push(modLoaded);
+        }
+        else {
+            for (const m in modLoaded) {
+                const module = modLoaded[m];
+                newClassList.push(module);
+            }
+        }
+        debug('newClassList size %s', newClassList.length);
+        let remapping = false;
+        if (types_1.Types.isClass(modLoaded) || types_1.Types.isFunction(modLoaded)) {
+            const newId = decorator_1.DecoratorManager.getProviderUUId(modLoaded);
+            const name = decorator_1.DecoratorManager.getProviderName(modLoaded);
+            if (nameList[name]) {
+                debug('find old class name %s and will be remapping', name);
+                this.remapping(nameList[name], newId);
+            }
+            debug('bindModule %s', newId);
+            remapping = true;
+            this.bindModule(modLoaded, {
+                namespace: decorator_1.MAIN_MODULE_KEY,
+                srcPath: modifyFilePath,
+                createFrom: 'file',
+            });
+        }
+        else {
+            for (const m in modLoaded) {
+                const module = modLoaded[m];
+                if (types_1.Types.isClass(module) || types_1.Types.isFunction(module)) {
+                    const newId = decorator_1.DecoratorManager.getProviderUUId(module);
+                    const name = decorator_1.DecoratorManager.getProviderName(module);
+                    if (nameList[name] !== newId) {
+                        if (nameList[name]) {
+                            debug('find old class name %s and will be remapping', name);
+                            this.remapping(nameList[name], newId);
+                        }
+                        debug('bindModule %s', newId);
+                        remapping = true;
+                        this.bindModule(module, {
+                            namespace: decorator_1.MAIN_MODULE_KEY,
+                            srcPath: modifyFilePath,
+                            createFrom: 'file',
+                        });
+                    }
+                }
+            }
+        }
+        return (requireCacheCleaned &&
+            oldDefinitionList.length > 0 &&
+            newClassList.length > 0 &&
+            remapping);
+    }
+    getIdentifier(identifier) {
+        // 从老的 id 映射成新的 id
+        let name = 'unknown';
+        if (typeof identifier !== 'string') {
+            name = decorator_1.DecoratorManager.getProviderName(identifier);
+            identifier = decorator_1.DecoratorManager.getProviderUUId(identifier);
+        }
+        debug('check identifier from %s %s', name, identifier);
+        if (this.modifyClassMapping.has(identifier)) {
+            debug('getIdentifier from modifyClassMapping %s -> %s', identifier, this.modifyClassMapping.get(identifier));
+            return this.modifyClassMapping.get(identifier);
+        }
+        return identifier;
+    }
+    findDefinitionByPath(filePath) {
+        const results = [];
+        // 遍历 registry
+        for (const definition of this.registry.values()) {
+            if (definition.srcPath === filePath) {
+                results.push(definition);
+            }
+        }
+        return results;
+    }
+    findRequireCacheAndClear(absolutePath) {
+        let cleaned = false;
+        const cacheKey = require.resolve(absolutePath);
+        const cache = require.cache[cacheKey];
+        if (cache) {
+            debug('clear cache %s', cacheKey);
+            delete require.cache[cacheKey];
+            cleaned = true;
+        }
+        return cleaned;
+    }
+    remapping(oldId, newId) {
+        // 新老 id 做个重新映射，如果第一次 1 -> 2， 第二次输入 2 -> 3，那么要变成 1 -> 3
+        for (const [key, value] of this.modifyClassMapping.entries()) {
+            if (value === oldId) {
+                debug('remapping key = %s, %s -> %s', key, oldId, newId);
+                // Update the mapping to the new newId
+                this.modifyClassMapping.set(key, newId);
+            }
+        }
+        debug('new remapping key = %s, value = %s', oldId, newId);
+        // Set the new mapping
+        this.modifyClassMapping.set(oldId, newId);
+    }
+}
+exports.DynamicMidwayContainer = DynamicMidwayContainer;
+//# sourceMappingURL=dynamicContainer.js.map

package/dist/context/managedResolverFactory.d.ts

@@ -1,55 +1,29 @@
-import { IManagedInstance, IManagedResolver, IManagedResolverFactoryCreateOptions, IMidwayContainer, InjectModeEnum, IObjectDefinition, ObjectIdentifier } from '../interface';
-export declare class ManagedReference implements IManagedInstance {
-    type: string;
-    name: string;
-    injectMode: InjectModeEnum;
-    args?: any;
-}
+import { ClassType, IMidwayContainer, IMidwayGlobalContainer } from '../interface';
 /**
  * 解析工厂
  */
 export declare class ManagedResolverFactory {
-    private resolvers;
     private creating;
-    singletonCache: Map<ObjectIdentifier, any>;
-    context: IMidwayContainer;
-    constructor(context: IMidwayContainer);
-    registerResolver(resolver: IManagedResolver): void;
-    resolveManaged(managed: IManagedInstance, originPropertyName: string): any;
-    resolveManagedAsync(managed: IManagedInstance, originPropertyName: string): Promise<any>;
+    context: IMidwayGlobalContainer;
+    constructor(context: IMidwayGlobalContainer);
     /**
      * 同步创建对象
-     * @param opt
-     */
-    create(opt: IManagedResolverFactoryCreateOptions): any;
-    /**
-     * 异步创建对象
-     * @param opt
+     * @param identifier
+     * @param args
+     * @param currentContext
      */
-    createAsync(opt: IManagedResolverFactoryCreateOptions): Promise<any>;
+    create<T = any>(identifier: ClassType<T> | string, args: any[], currentContext: IMidwayContainer): T;
+    createAsync<T = any>(identifier: ClassType<T> | string, args: any[], currentContext: IMidwayContainer): Promise<T>;
     destroyCache(): Promise<void>;
-    /**
-     * 触发单例初始化结束事件
-     * @param definition 单例定义
-     * @param success 成功 or 失败
-     */
-    private removeCreateStatus;
-    isCreating(definition: IObjectDefinition): boolean;
-    private compareAndSetCreateStatus;
-    /**
-     * 创建对象定义的代理访问逻辑
-     * @param definition 对象定义
-     */
-    private createProxyReference;
-    /**
-     * 遍历依赖树判断是否循环依赖
-     * @param identifier 目标id
-     * @param definition 定义描述
-     * @param depth
-     */
-    depthFirstSearch(identifier: string, definition: IObjectDefinition, depth?: string[]): boolean;
     private getObjectEventTarget;
     private checkSingletonInvokeRequest;
     private setInstanceScope;
+    private createInstance;
+    private initializeInstance;
+    private initializeInstanceAsync;
+    private storeInstanceScope;
+    private getObjectDefinition;
+    private getCurrentMatchedContext;
+    private translateIdentifiers;
 }
 //# sourceMappingURL=managedResolverFactory.d.ts.map