@midwayjs/core 4.0.0-alpha.1 → 4.0.0-beta.10

package/dist/common/serviceFactory.js

@@ -13,15 +13,18 @@ exports.ServiceFactory = void 0;
 const extend_1 = require("../util/extend");
 const priorityManager_1 = require("./priorityManager");
 const decorator_1 = require("../decorator");
+const types_1 = require("../util/types");
 /**
  * 多客户端工厂实现
  */
 class ServiceFactory {
-    constructor() {
-        this.clients = new Map();
-        this.options = {};
-    }
-    async initClients(options = {}) {
+    clients = new Map();
+    clientPriority;
+    options = {};
+    priorityManager;
+    // for multi client with initialization
+    creatingClients = new Map();
+    async initClients(options = {}, initOptions = {}) {
         this.options = options;
         // merge options.client to options.clients['default']
         if (options.client) {
@@ -29,10 +32,17 @@ class ServiceFactory {
             options.clients['default'] = options.clients['default'] || {};
             (0, extend_1.extend)(true, options.clients['default'], options.client);
         }
-        // multi client
         if (options.clients) {
-            for (const id of Object.keys(options.clients)) {
-                await this.createInstance(options.clients[id], id);
+            const entries = Object.entries(options.clients);
+            if (initOptions.concurrent) {
+                // multi client with concurrent initialization
+                await Promise.all(entries.map(([id, config]) => this.createInstance(config, id)));
+            }
+            else {
+                // multi client with serial initialization
+                for (const [id, config] of entries) {
+                    await this.createInstance(config, id);
+                }
             }
         }
         // set priority
@@ -45,21 +55,46 @@ class ServiceFactory {
         return this.clients.has(id);
     }
     async createInstance(config, clientName) {
+        if (clientName) {
+            if (this.has(clientName)) {
+                return this.get(clientName);
+            }
+            if (this.creatingClients.has(clientName)) {
+                return this.creatingClients.get(clientName);
+            }
+        }
         // options.default will be merge in to options.clients[id]
         config = (0, extend_1.extend)(true, {}, this.options['default'], config);
-        const client = await this.createClient(config, clientName);
-        if (client) {
+        const clientCreatingPromise = this.createClient(config, clientName);
+        if (clientCreatingPromise && types_1.Types.isPromise(clientCreatingPromise)) {
             if (clientName) {
-                this.clients.set(clientName, client);
+                this.creatingClients.set(clientName, clientCreatingPromise);
             }
-            return client;
+            return clientCreatingPromise
+                .then(client => {
+                if (clientName) {
+                    this.clients.set(clientName, client);
+                }
+                return client;
+            })
+                .finally(() => {
+                if (clientName) {
+                    this.creatingClients.delete(clientName);
+                }
+            });
+        }
+        // 处理同步返回的情况
+        if (clientName) {
+            this.clients.set(clientName, clientCreatingPromise);
         }
+        return clientCreatingPromise;
     }
     async destroyClient(client, clientName) { }
     async stop() {
         for (const [name, value] of this.clients.entries()) {
             await this.destroyClient(value, name);
         }
+        this.clients.clear();
     }
     getDefaultClientName() {
         return this.options['defaultClientName'];

package/dist/common/typedResourceManager.js

@@ -2,10 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypedResourceManager = void 0;
 class TypedResourceManager {
+    typedResourceInitializerOptions;
+    resourceMap = new Map();
+    resourceBindingMap = new Map();
     constructor(typedResourceInitializerOptions) {
         this.typedResourceInitializerOptions = typedResourceInitializerOptions;
-        this.resourceMap = new Map();
-        this.resourceBindingMap = new Map();
     }
     async createResource(resourceName, resourceInitializeConfig) {
         const resource = await this.typedResourceInitializerOptions.resourceInitialize(resourceInitializeConfig, resourceName);

package/dist/common/webGenerator.js

@@ -13,6 +13,8 @@ const error_1 = require("../error");
 const middlewareService_1 = require("../service/middlewareService");
 const debug = util.debuglog('midway:debug');
 class WebControllerGenerator {
+    app;
+    midwayWebRouterService;
     constructor(app, midwayWebRouterService) {
         this.app = app;
         this.midwayWebRouterService = midwayWebRouterService;

package/dist/config/config.default.js

@@ -5,7 +5,10 @@ exports.default = (appInfo) => {
     const isDevelopment = (0, util_1.isDevelopmentEnvironment)((0, util_1.getCurrentEnvironment)());
     return {
         core: {
-            healthCheckTimeout: 1000,
+            healthCheckTimeout: 1_000,
+            configLoadTimeout: 10_000,
+            readyTimeout: 30_000,
+            serverReadyTimeout: 30_000,
         },
         asyncContextManager: {
             enable: true,

package/dist/context/componentLoader.js

@@ -9,10 +9,11 @@ const util = require("util");
 const util_1 = require("../util");
 const debug = util.debuglog('midway:debug');
 class ComponentConfigurationLoader {
+    container;
+    loadedMap = new WeakMap();
+    namespaceList = [];
     constructor(container) {
         this.container = container;
-        this.loadedMap = new WeakMap();
-        this.namespaceList = [];
     }
     async load(module) {
         let namespace = decorator_1.MAIN_MODULE_KEY;

package/dist/context/container.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { ClassType, IIdentifierRelationShip, IMidwayContainer, IMidwayGlobalContainer, IObjectDefinition, IObjectDefinitionRegistry, ObjectIdentifier, ScopeEnum } from '../interface';
 import { ManagedResolverFactory } from './managedResolverFactory';
 import { EventEmitter } from 'events';
@@ -21,9 +20,9 @@ export declare class MidwayContainer implements IMidwayGlobalContainer {
     get identifierMapping(): IIdentifierRelationShip;
     addNamespace(ns: string): void;
     bindClass(exports: any, options?: Partial<IObjectDefinition>): void;
-    bind<T>(target: T, options?: Partial<IObjectDefinition>): void;
-    bind<T>(identifier: ObjectIdentifier, target: T, options?: Partial<IObjectDefinition>): void;
-    protected bindModule(module: any, options: Partial<IObjectDefinition>): void;
+    bind<T>(target: T, options?: Partial<IObjectDefinition>): IObjectDefinition | undefined;
+    bind<T>(identifier: ObjectIdentifier, target: T, options?: Partial<IObjectDefinition>): IObjectDefinition | undefined;
+    protected bindModule(module: any, options: Partial<IObjectDefinition>): IObjectDefinition | undefined;
     setAttr(key: string, value: any): void;
     getAttr<T>(key: string): T;
     getIdentifier(identifier: ClassType | string): string;
@@ -37,6 +36,7 @@ export declare class MidwayContainer implements IMidwayGlobalContainer {
      * @param target
      */
     registerObject(identifier: ObjectIdentifier, target: any): void;
+    removeObject(identifier: ObjectIdentifier): void;
     onBeforeBind(fn: (Clzz: any, options: {
         context: IMidwayContainer;
         definition: IObjectDefinition;

package/dist/context/container.js

@@ -17,18 +17,19 @@ const debug = util.debuglog('midway:debug');
 const debugBind = util.debuglog('midway:bind');
 const debugSpaceLength = 9;
 class MidwayContainer {
+    _resolverFactory = null;
+    _registry = null;
+    _identifierMapping = null;
+    _objectCreateEventTarget;
+    // 仅仅用于兼容 requestContainer 的 ctx
+    ctx = constants_1.SINGLETON_CONTAINER_CTX;
+    attrMap = new Map();
+    namespaceSet = new Set();
+    _id = util_1.Utils.generateRandomId();
     get id() {
         return this._id;
     }
     constructor() {
-        this._resolverFactory = null;
-        this._registry = null;
-        this._identifierMapping = null;
-        // 仅仅用于兼容 requestContainer 的 ctx
-        this.ctx = constants_1.SINGLETON_CONTAINER_CTX;
-        this.attrMap = new Map();
-        this.namespaceSet = new Set();
-        this._id = util_1.Utils.generateRandomId();
         // 防止直接从applicationContext.getAsync or get对象实例时依赖当前上下文信息出错
         // ctx is in requestContainer
         this.registerObject(constants_1.REQUEST_CTX_KEY, this.ctx);
@@ -162,13 +163,14 @@ class MidwayContainer {
         if (definition) {
             this.registry.registerDefinition(definition.id, definition);
         }
+        return definition;
     }
     bindModule(module, options) {
         if (types_1.Types.isClass(module)) {
             const providerId = decorator_1.DecoratorManager.getProviderUUId(module);
             if (providerId) {
                 this.identifierMapping.saveClassRelation(module, options?.namespace);
-                this.bind(providerId, module, options);
+                return this.bind(providerId, module, options);
             }
             else {
                 // no provide or js class must be skip
@@ -182,7 +184,7 @@ class MidwayContainer {
                 }
                 const uuid = util_1.Utils.generateRandomId();
                 this.identifierMapping.saveFunctionRelation(info.id, uuid);
-                this.bind(uuid, module, {
+                return this.bind(uuid, module, {
                     scope: info.scope,
                     namespace: options.namespace,
                     srcPath: options.srcPath,
@@ -231,6 +233,9 @@ class MidwayContainer {
     registerObject(identifier, target) {
         this.registry.registerObject(identifier, target);
     }
+    removeObject(identifier) {
+        this.registry.removeObject(identifier);
+    }
     onBeforeBind(fn) {
         this.objectCreateEventTarget.on(interface_1.ObjectLifeCycleEvent.BEFORE_BIND, fn);
     }

package/dist/context/definitionRegistry.d.ts

@@ -5,6 +5,7 @@ import { IIdentifierRelationShip, IObjectDefinition, IObjectDefinitionRegistry,
 export declare class ObjectDefinitionRegistry extends Map implements IObjectDefinitionRegistry {
     private singletonIds;
     private _identifierRelation;
+    private objectCache;
     get identifierRelation(): IIdentifierRelationShip;
     set identifierRelation(identifierRelation: IIdentifierRelationShip);
     get identifiers(): any[];
@@ -18,6 +19,7 @@ export declare class ObjectDefinitionRegistry extends Map implements IObjectDefi
     clearAll(): void;
     hasObject(identifier: ObjectIdentifier): boolean;
     registerObject(identifier: ObjectIdentifier, target: any): void;
+    removeObject(identifier: ObjectIdentifier): void;
     getObject(identifier: ObjectIdentifier): any;
     getIdentifierRelation(): IIdentifierRelationShip;
     setIdentifierRelation(identifierRelation: IIdentifierRelationShip): void;

package/dist/context/definitionRegistry.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectDefinitionRegistry = void 0;
 const decorator_1 = require("../decorator");
-const PREFIX = '_id_default_';
 class LegacyIdentifierRelation extends Map {
     saveClassRelation(module, namespace) {
         const providerId = decorator_1.DecoratorManager.getProviderUUId(module);
@@ -35,11 +34,9 @@ class LegacyIdentifierRelation extends Map {
     }
 }
 class ObjectDefinitionRegistry extends Map {
-    constructor() {
-        super(...arguments);
-        this.singletonIds = [];
-        this._identifierRelation = new LegacyIdentifierRelation();
-    }
+    singletonIds = [];
+    _identifierRelation = new LegacyIdentifierRelation();
+    objectCache = new Map();
     get identifierRelation() {
         if (!this._identifierRelation) {
             this._identifierRelation = new LegacyIdentifierRelation();
@@ -50,13 +47,7 @@ class ObjectDefinitionRegistry extends Map {
         this._identifierRelation = identifierRelation;
     }
     get identifiers() {
-        const ids = [];
-        for (const key of this.keys()) {
-            if (key.indexOf(PREFIX) === -1) {
-                ids.push(key);
-            }
-        }
-        return ids;
+        return Array.from(this.keys());
     }
     get count() {
         return this.size;
@@ -93,18 +84,22 @@ class ObjectDefinitionRegistry extends Map {
     }
     clearAll() {
         this.singletonIds = [];
+        this.objectCache.clear();
         this.clear();
     }
     hasObject(identifier) {
         identifier = this.identifierRelation.getRelation(identifier) ?? identifier;
-        return this.has(PREFIX + identifier);
+        return this.objectCache.has(identifier);
     }
     registerObject(identifier, target) {
-        this.set(PREFIX + identifier, target);
+        this.objectCache.set(identifier, target);
+    }
+    removeObject(identifier) {
+        this.objectCache.delete(identifier);
     }
     getObject(identifier) {
         identifier = this.identifierRelation.getRelation(identifier) ?? identifier;
-        return this.get(PREFIX + identifier);
+        return this.objectCache.get(identifier);
     }
     getIdentifierRelation() {
         return this.identifierRelation;

package/dist/context/dynamicContainer.d.ts

@@ -0,0 +1,17 @@
+import { MidwayContainer } from './container';
+import { ClassType } from '../interface';
+/**
+ * 尝试用于开发时动态更新的 IoC 容器
+ */
+export declare class DynamicMidwayContainer extends MidwayContainer {
+    private moduleType;
+    private modifyClassMapping;
+    private idRefMapping;
+    constructor();
+    updateDefinition(modifyFilePath: string): Promise<boolean>;
+    getIdentifier(identifier: ClassType | string): string;
+    private findDefinitionByPath;
+    private findRequireCacheAndClear;
+    private remapping;
+}
+//# sourceMappingURL=dynamicContainer.d.ts.map

package/dist/context/dynamicContainer.js

@@ -0,0 +1,203 @@
+"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 {
+    moduleType;
+    modifyClassMapping = new Map();
+    idRefMapping = new Map();
+    constructor() {
+        super();
+        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,10 +1,9 @@
-import { ClassType, IMidwayContainer, IMidwayGlobalContainer, ObjectIdentifier } from '../interface';
+import { ClassType, IMidwayContainer, IMidwayGlobalContainer } from '../interface';
 /**
  * 解析工厂
  */
 export declare class ManagedResolverFactory {
     private creating;
-    singletonCache: Map<ObjectIdentifier, any>;
     context: IMidwayGlobalContainer;
     constructor(context: IMidwayGlobalContainer);
     /**

package/dist/context/managedResolverFactory.js

@@ -31,9 +31,9 @@ function formatObjectIdentifier(identifier) {
  * 解析工厂
  */
 class ManagedResolverFactory {
+    creating = new Map();
+    context;
     constructor(context) {
-        this.creating = new Map();
-        this.singletonCache = new Map();
         this.context = context;
     }
     /**
@@ -89,18 +89,19 @@ class ManagedResolverFactory {
         return newInstance ?? instance;
     }
     async destroyCache() {
-        for (const key of this.singletonCache.keys()) {
+        for (const key of this.context.registry.getSingletonDefinitionIds()) {
             const definition = this.getObjectDefinition(key);
             if (definition.creator) {
-                const inst = this.singletonCache.get(key);
+                const inst = this.context.getObject(key);
                 this.getObjectEventTarget().emit(interface_1.ObjectLifeCycleEvent.BEFORE_DESTROY, inst, {
                     context: this.context,
                     definition,
                 });
                 await definition.creator.doDestroyAsync(inst);
             }
+            // clean singleton object cache
+            this.context.removeObject(key);
         }
-        this.singletonCache.clear();
         this.creating.clear();
     }
     getObjectEventTarget() {
@@ -149,10 +150,16 @@ class ManagedResolverFactory {
         }
         if (definition.isSingletonScope()) {
             currentContext = this.context;
-            if (this.singletonCache.has(definition.id)) {
+            if (this.context.hasObject(definition.id)) {
                 debug(`[core]: "${definition.id}(${definition.name})" get from singleton cache.`);
-                return this.singletonCache.get(definition.id);
+                return this.context.getObject(definition.id);
             }
+            // if (this.singletonCache.has(definition.id)) {
+            //   debug(
+            //     `[core]: "${definition.id}(${definition.name})" get from singleton cache.`
+            //   );
+            //   return this.singletonCache.get(definition.id);
+            // }
         }
         // 使用 creationPath 检查循环依赖
         if (creationPath.has(definition.id)) {
@@ -323,7 +330,8 @@ class ManagedResolverFactory {
         if (definition.id) {
             if (definition.isSingletonScope()) {
                 debug(`[core]: "${definition.id}(${definition.name})" set to singleton cache`);
-                this.singletonCache.set(definition.id, instance);
+                this.context.registerObject(definition.id, instance);
+                // this.singletonCache.set(definition.id, instance);
                 this.setInstanceScope(instance, interface_1.ScopeEnum.Singleton);
             }
             else if (definition.isRequestScope()) {

package/dist/context/providerWrapper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.providerWrapper = void 0;
+exports.providerWrapper = providerWrapper;
 const constants_1 = require("../constants");
 function providerWrapper(wrapperInfo) {
     for (const info of wrapperInfo) {
@@ -10,5 +10,4 @@ function providerWrapper(wrapperInfo) {
         });
     }
 }
-exports.providerWrapper = providerWrapper;
 //# sourceMappingURL=providerWrapper.js.map

package/dist/context/requestContainer.d.ts

@@ -13,6 +13,7 @@ export declare class MidwayRequestContainer implements IMidwayRequestContainer {
     hasDefinition(identifier: ObjectIdentifier): boolean;
     getDefinition(identifier: ObjectIdentifier): import("../interface").IObjectDefinition;
     registerObject(identifier: string, obj: any): void;
+    removeObject(identifier: ObjectIdentifier): void;
     hasObject(identifier: ObjectIdentifier): boolean;
     getObject<T>(identifier: ObjectIdentifier): T;
     setAttr(key: string, value: any): void;

package/dist/context/requestContainer.js

@@ -4,11 +4,14 @@ exports.MidwayRequestContainer = void 0;
 const constants_1 = require("../constants");
 const definitionRegistry_1 = require("./definitionRegistry");
 class MidwayRequestContainer {
+    ctx;
+    applicationContext;
+    parent;
+    registry = new definitionRegistry_1.ObjectDefinitionRegistry();
+    attrMap = new Map();
     constructor(ctx, applicationContext) {
         this.ctx = ctx;
         this.applicationContext = applicationContext;
-        this.registry = new definitionRegistry_1.ObjectDefinitionRegistry();
-        this.attrMap = new Map();
         this.parent = applicationContext;
         // update legacy relationship
         this.registry.setIdentifierRelation(this.applicationContext.registry.getIdentifierRelation());
@@ -44,6 +47,9 @@ class MidwayRequestContainer {
     registerObject(identifier, obj) {
         this.registry.registerObject(identifier, obj);
     }
+    removeObject(identifier) {
+        this.registry.removeObject(identifier);
+    }
     hasObject(identifier) {
         return this.registry.hasObject(identifier);
     }