@midwayjs/core 3.0.0-alpha.36 → 3.0.0-alpha.42

package/dist/context/container.js

@@ -4,17 +4,17 @@ exports.MidwayContainer = void 0;
 const decorator_1 = require("@midwayjs/decorator");
 const configuration_1 = require("../functional/configuration");
 const util = require("util");
-const definitionRegistry_1 = require("./definitionRegistry");
+const applicationContext_1 = require("./applicationContext");
 const interface_1 = require("../interface");
+const reflectTool_1 = require("../common/reflectTool");
 const constants_1 = require("../common/constants");
 const objectDefinition_1 = require("../definitions/objectDefinition");
 const functionDefinition_1 = require("../definitions/functionDefinition");
+const managed_1 = require("./managed");
 const resolverHandler_1 = require("./resolverHandler");
 const environmentService_1 = require("../service/environmentService");
 const configService_1 = require("../service/configService");
 const aspectService_1 = require("../service/aspectService");
-const managedResolverFactory_1 = require("./managedResolverFactory");
-const notFoundError_1 = require("../common/notFoundError");
 const debug = util.debuglog('midway:container:configuration');
 const globalDebugLogger = util.debuglog('midway:container');
 class ContainerConfiguration {
@@ -44,14 +44,19 @@ class ContainerConfiguration {
                     configurationOptions.namespace !== undefined) {
                     this.namespace = configurationOptions.namespace;
                 }
+                // if (i === 0 && this.namespace === MAIN_MODULE_KEY) {
+                //   // set conflictCheck
+                //   if (configurationOptions.conflictCheck === undefined) {
+                //     configurationOptions.conflictCheck = false;
+                //   }
+                //   this.container.disableConflictCheck =
+                //     !configurationOptions.conflictCheck;
+                // }
                 this.addImports(configurationOptions.imports);
-                this.addImportObjects(configurationOptions.importObjects);
                 this.addImportConfigs(configurationOptions.importConfigs);
                 this.bindConfigurationClass(configurationExport);
             }
         }
-        // bind module
-        this.container.bindClass(module, this.namespace);
     }
     addImportConfigs(importConfigs) {
         if (importConfigs && importConfigs.length) {
@@ -69,7 +74,7 @@ class ContainerConfiguration {
                 importPackage = require(importPackage);
             }
             // for package
-            const subContainerConfiguration = new ContainerConfiguration(this.container);
+            const subContainerConfiguration = this.container.createConfiguration();
             if ('Configuration' in importPackage) {
                 // component is object
                 debug('\n---------- start load configuration from submodule" ----------');
@@ -86,28 +91,15 @@ class ContainerConfiguration {
             }
         }
     }
-    /**
-     * 注册 importObjects
-     * @param objs configuration 中的 importObjects
-     */
-    addImportObjects(objs) {
-        if (objs) {
-            const keys = Object.keys(objs);
-            for (const key of keys) {
-                if (typeof objs[key] !== undefined) {
-                    this.container.registerObject(key, objs[key]);
-                }
-            }
-        }
-    }
     bindConfigurationClass(clzz, filePath) {
         if (clzz instanceof configuration_1.FunctionalConfiguration) {
             // 函数式写法不需要绑定到容器
         }
         else {
             // 普通类写法
-            (0, decorator_1.saveProviderId)(undefined, clzz);
-            const id = (0, decorator_1.getProviderUUId)(clzz);
+            const clzzName = `${decorator_1.LIFECYCLE_IDENTIFIER_PREFIX}${(0, decorator_1.classNamed)(clzz.name)}`;
+            const id = (0, decorator_1.generateProvideId)(clzzName, this.namespace);
+            (0, decorator_1.saveProviderId)(id, clzz, true);
             this.container.bind(id, clzz, {
                 namespace: this.namespace,
                 srcPath: filePath,
@@ -146,48 +138,23 @@ class ContainerConfiguration {
         return mods;
     }
 }
-class MidwayContainer {
-    constructor(parent) {
-        this._resolverFactory = null;
-        this._registry = null;
-        this._identifierMapping = null;
-        this.parent = null;
+class MidwayContainer extends applicationContext_1.BaseApplicationContext {
+    constructor() {
+        super(...arguments);
         this.debugLogger = globalDebugLogger;
+        this.definitionMetadataList = [];
         // 仅仅用于兼容requestContainer的ctx
         this.ctx = {};
         this.attrMap = new Map();
         this.isLoad = false;
-        this.parent = parent;
-        this.init();
     }
     init() {
         this.initService();
-        this.resolverHandler = new resolverHandler_1.ResolverHandler(this, this.managedResolverFactory);
+        this.resolverHandler = new resolverHandler_1.ResolverHandler(this, this.getManagedResolverFactory());
         // 防止直接从applicationContext.getAsync or get对象实例时依赖当前上下文信息出错
         // ctx is in requestContainer
         this.registerObject(interface_1.REQUEST_CTX_KEY, this.ctx);
     }
-    get registry() {
-        if (!this._registry) {
-            this._registry = new definitionRegistry_1.ObjectDefinitionRegistry();
-        }
-        return this._registry;
-    }
-    set registry(registry) {
-        this._registry = registry;
-    }
-    get managedResolverFactory() {
-        if (!this._resolverFactory) {
-            this._resolverFactory = new managedResolverFactory_1.ManagedResolverFactory(this);
-        }
-        return this._resolverFactory;
-    }
-    get identifierMapping() {
-        if (!this._identifierMapping) {
-            this._identifierMapping = this.registry.getIdentifierRelation();
-        }
-        return this._identifierMapping;
-    }
     initService() {
         this.environmentService = new environmentService_1.MidwayEnvironmentService();
         this.configService = new configService_1.MidwayConfigService(this);
@@ -197,7 +164,7 @@ class MidwayContainer {
         this.isLoad = true;
         if (module) {
             // load configuration
-            const configuration = new ContainerConfiguration(this);
+            const configuration = this.createConfiguration();
             configuration.load(module);
         }
         // register base config hook
@@ -222,91 +189,206 @@ class MidwayContainer {
         // init config service
         this.configService.load();
     }
+    createConfiguration() {
+        return new ContainerConfiguration(this);
+    }
     bindClass(exports, namespace = '', filePath) {
         if ((0, decorator_1.isClass)(exports) || (0, decorator_1.isFunction)(exports)) {
-            this.bindModule(exports, {
-                namespace,
-                srcPath: filePath,
-            });
+            this.bindModule(exports, namespace, filePath);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
                 if ((0, decorator_1.isClass)(module) || (0, decorator_1.isFunction)(module)) {
-                    this.bindModule(module, {
-                        namespace,
-                        srcPath: filePath,
-                    });
+                    this.bindModule(module, namespace, filePath);
                 }
             }
         }
     }
     bind(identifier, target, options) {
         var _a;
+        const definitionMeta = {};
+        this.definitionMetadataList.push(definitionMeta);
         if ((0, decorator_1.isClass)(identifier) || (0, decorator_1.isFunction)(identifier)) {
-            return this.bindModule(identifier, target);
+            options = target;
+            target = identifier;
+            identifier = (0, decorator_1.getProviderId)(target);
         }
-        if (this.registry.hasDefinition(identifier)) {
-            // 如果 definition 存在就不再重复 bind
-            return;
-        }
-        let definition;
         if ((0, decorator_1.isClass)(target)) {
-            definition = new objectDefinition_1.ObjectDefinition();
+            definitionMeta.definitionType = 'object';
         }
         else {
-            definition = new functionDefinition_1.FunctionDefinition();
+            definitionMeta.definitionType = 'function';
             if (!(0, decorator_1.isAsyncFunction)(target)) {
-                definition.asynchronous = false;
+                definitionMeta.asynchronous = false;
             }
         }
-        definition.path = target;
-        definition.id = identifier;
-        definition.srcPath = (options === null || options === void 0 ? void 0 : options.srcPath) || null;
-        definition.namespace = (options === null || options === void 0 ? void 0 : options.namespace) || '';
-        definition.scope = (options === null || options === void 0 ? void 0 : options.scope) || decorator_1.ScopeEnum.Request;
-        this.debugLogger(`  bind id => [${definition.id}]`);
-        // inject properties
-        const props = (0, decorator_1.getPropertyInject)(target);
-        for (const p in props) {
-            const propertyMeta = props[p];
-            this.debugLogger(`  inject properties => [${propertyMeta}]`);
-            const refManaged = new managedResolverFactory_1.ManagedReference();
-            refManaged.args = propertyMeta.args;
-            refManaged.name = propertyMeta.value;
-            definition.properties.set(propertyMeta['targetKey'], refManaged);
+        definitionMeta.path = target;
+        definitionMeta.id = identifier;
+        definitionMeta.srcPath = (options === null || options === void 0 ? void 0 : options.srcPath) || null;
+        definitionMeta.namespace = (options === null || options === void 0 ? void 0 : options.namespace) || '';
+        definitionMeta.scope = (options === null || options === void 0 ? void 0 : options.scope) || decorator_1.ScopeEnum.Request;
+        definitionMeta.autowire = (options === null || options === void 0 ? void 0 : options.isAutowire) !== false;
+        this.debugLogger(`  bind id => [${definitionMeta.id}]`);
+        // inject constructArgs
+        const constructorMetaData = (0, decorator_1.getConstructorInject)(target);
+        if (constructorMetaData) {
+            this.debugLogger(`inject constructor => length = ${target['length']}`);
+            definitionMeta.constructorArgs = [];
+            const maxLength = Math.max.apply(null, Object.keys(constructorMetaData));
+            for (let i = 0; i < maxLength + 1; i++) {
+                const propertyMeta = constructorMetaData[i];
+                if (propertyMeta) {
+                    definitionMeta.constructorArgs.push({
+                        type: 'ref',
+                        value: propertyMeta[0].value,
+                        args: propertyMeta[0].args,
+                    });
+                }
+                else {
+                    definitionMeta.constructorArgs.push({
+                        type: 'value',
+                        value: propertyMeta === null || propertyMeta === void 0 ? void 0 : propertyMeta[0].value,
+                    });
+                }
+            }
         }
-        // inject custom properties
-        const customProps = (0, decorator_1.getClassExtendedMetadata)(decorator_1.INJECT_CUSTOM_TAG, target);
-        for (const p in customProps) {
-            const propertyMeta = customProps[p];
-            definition.handlerProps.push({
-                handlerKey: propertyMeta.key,
-                prop: propertyMeta,
-            });
+        // inject properties
+        const props = (0, reflectTool_1.recursiveGetPrototypeOf)(target);
+        props.push(target);
+        definitionMeta.properties = [];
+        definitionMeta.handlerProps = [];
+        for (const p of props) {
+            const metaData = (0, reflectTool_1.getOwnMetadata)(decorator_1.TAGGED_PROP, p);
+            if (metaData) {
+                this.debugLogger(`  inject properties => [${Object.keys(metaData)}]`);
+                for (const metaKey in metaData) {
+                    for (const propertyMeta of metaData[metaKey]) {
+                        definitionMeta.properties.push({
+                            metaKey,
+                            args: propertyMeta.args,
+                            value: propertyMeta.value,
+                        });
+                    }
+                }
+            }
+            const meta = (0, reflectTool_1.getOwnMetadata)(decorator_1.INJECT_CLASS_KEY_PREFIX, p);
+            if (meta) {
+                for (const [key, vals] of meta) {
+                    if (Array.isArray(vals)) {
+                        for (const val of vals) {
+                            if (val.key !== undefined &&
+                                val.key !== null &&
+                                typeof val.propertyName === 'string') {
+                                definitionMeta.handlerProps.push({
+                                    handlerKey: decorator_1.DecoratorManager.removeDecoratorClassKeySuffix(key),
+                                    prop: val,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
         }
         // @async, @init, @destroy @scope
-        const objDefOptions = (_a = (0, decorator_1.getObjectDefinition)(target)) !== null && _a !== void 0 ? _a : {};
+        const objDefOptions = (_a = (0, decorator_1.getObjectDefProps)(target)) !== null && _a !== void 0 ? _a : {};
         if (objDefOptions.initMethod) {
             this.debugLogger(`  register initMethod = ${objDefOptions.initMethod}`);
-            definition.initMethod = objDefOptions.initMethod;
+            definitionMeta.initMethod = objDefOptions.initMethod;
         }
         if (objDefOptions.destroyMethod) {
             this.debugLogger(`  register destroyMethod = ${objDefOptions.destroyMethod}`);
-            definition.destroyMethod = objDefOptions.destroyMethod;
+            definitionMeta.destroyMethod = objDefOptions.destroyMethod;
         }
         if (objDefOptions.scope) {
             this.debugLogger(`  register scope = ${objDefOptions.scope}`);
-            definition.scope = objDefOptions.scope;
+            definitionMeta.scope = objDefOptions.scope;
+        }
+        // 把源信息变成真正的对象定义
+        this.restoreDefinition(definitionMeta);
+    }
+    restoreDefinition(definitionMeta) {
+        let definition;
+        if (definitionMeta.definitionType === 'object') {
+            definition = new objectDefinition_1.ObjectDefinition();
+        }
+        else {
+            definition = new functionDefinition_1.FunctionDefinition();
+            if (!definitionMeta.asynchronous) {
+                definition.asynchronous = false;
+            }
+        }
+        definition.path = definitionMeta.path;
+        definition.id = definitionMeta.id;
+        definition.srcPath = definitionMeta.srcPath;
+        definition.namespace = definitionMeta.namespace;
+        this.debugLogger(`  bind id => [${definition.id}]`);
+        // inject constructArgs
+        if (definitionMeta.constructorArgs &&
+            definitionMeta.constructorArgs.length) {
+            for (const constructorInfo of definitionMeta.constructorArgs) {
+                if (constructorInfo.type === 'ref') {
+                    const refManagedIns = new managed_1.ManagedReference();
+                    const name = constructorInfo.value;
+                    refManagedIns.args = constructorInfo.args;
+                    if (this.midwayIdentifiers.includes(name)) {
+                        refManagedIns.name = name;
+                    }
+                    else {
+                        refManagedIns.name = (0, decorator_1.generateProvideId)(name, definition.namespace);
+                    }
+                    definition.constructorArgs.push(refManagedIns);
+                }
+                else {
+                    // inject empty value
+                    const valueManagedIns = new managed_1.ManagedValue();
+                    valueManagedIns.valueType = constructorInfo.type;
+                    valueManagedIns.value = constructorInfo.value;
+                    definition.constructorArgs.push(valueManagedIns);
+                }
+            }
+        }
+        // inject properties
+        for (const propertyMeta of definitionMeta.properties) {
+            const refManaged = new managed_1.ManagedReference();
+            refManaged.args = propertyMeta.args;
+            if (this.midwayIdentifiers.includes(propertyMeta.value)) {
+                refManaged.name = propertyMeta.value;
+            }
+            else {
+                refManaged.name = (0, decorator_1.generateProvideId)(propertyMeta.value, definition.namespace);
+            }
+            definition.properties.set(propertyMeta.metaKey, refManaged);
+        }
+        definition.asynchronous = definitionMeta.asynchronous;
+        definition.initMethod = definitionMeta.initMethod;
+        definition.destroyMethod = definitionMeta.destroyMethod;
+        definition.scope = definitionMeta.scope;
+        definition.autowire = definitionMeta.autowire;
+        definition.handlerProps = definitionMeta.handlerProps;
+        this.registerDefinition(definitionMeta.id, definition);
+    }
+    restoreDefinitions(definitionMetadataList) {
+        if (definitionMetadataList && definitionMetadataList.length) {
+            for (const definitionMeta of definitionMetadataList) {
+                this.restoreDefinition(definitionMeta);
+            }
         }
-        this.registry.registerDefinition(definition.id, definition);
     }
-    bindModule(module, options = {}) {
+    getDefinitionMetaList() {
+        return this.definitionMetadataList;
+    }
+    bindModule(module, namespace = '', filePath) {
         if ((0, decorator_1.isClass)(module)) {
-            const providerId = (0, decorator_1.getProviderUUId)(module);
+            const providerId = (0, decorator_1.isProvide)(module) ? (0, decorator_1.getProviderId)(module) : null;
             if (providerId) {
-                this.identifierMapping.saveClassRelation(module, options.namespace);
-                this.bind(providerId, module, options);
+                if (namespace) {
+                    (0, decorator_1.saveClassMetadata)(decorator_1.PRIVATE_META_DATA_KEY, { namespace, providerId, srcPath: filePath }, module);
+                }
+                this.bind((0, decorator_1.generateProvideId)(providerId, namespace), module, {
+                    namespace,
+                    srcPath: filePath,
+                });
             }
             else {
                 // no provide or js class must be skip
@@ -318,12 +400,11 @@ class MidwayContainer {
                 if (!info.scope) {
                     info.scope = decorator_1.ScopeEnum.Request;
                 }
-                const uuid = (0, decorator_1.generateRandomId)();
-                this.identifierMapping.saveFunctionRelation(info.id, uuid);
-                this.bind(uuid, module, {
+                this.bind((0, decorator_1.generateProvideId)(info.id, namespace), module, {
                     scope: info.scope,
-                    namespace: options.namespace,
-                    srcPath: options.srcPath,
+                    isAutowire: info.isAutowire,
+                    namespace,
+                    srcPath: filePath,
                 });
             }
         }
@@ -335,7 +416,7 @@ class MidwayContainer {
         this.fileDetector = fileDetector;
     }
     createChild() {
-        return new MidwayContainer(this);
+        return new MidwayContainer('', this);
     }
     registerDataHandler(handlerType, handler) {
         this.resolverHandler.registerHandler(handlerType, handler);
@@ -367,80 +448,6 @@ class MidwayContainer {
     getAttr(key) {
         return this.attrMap.get(key);
     }
-    getIdentifier(target) {
-        return (0, decorator_1.getProviderUUId)(target);
-    }
-    findRegisterObject(identifier) {
-        const ins = this.registry.getObject(identifier);
-        return this.aspectService.wrapperAspectToInstance(ins);
-    }
-    getManagedResolverFactory() {
-        if (!this._resolverFactory) {
-            this._resolverFactory = new managedResolverFactory_1.ManagedResolverFactory(this);
-        }
-        return this._resolverFactory;
-    }
-    async stop() {
-        await this.getManagedResolverFactory().destroyCache();
-        this.registry.clearAll();
-    }
-    async ready() {
-        await this.loadDefinitions();
-    }
-    get(identifier, args) {
-        if (typeof identifier !== 'string') {
-            identifier = this.getIdentifier(identifier);
-        }
-        if (this.registry.hasObject(identifier)) {
-            return this.registry.getObject(identifier);
-        }
-        const definition = this.registry.getDefinition(identifier);
-        if (!definition && this.parent) {
-            return this.parent.get(identifier, args);
-        }
-        if (!definition) {
-            throw new notFoundError_1.NotFoundError(identifier);
-        }
-        return this.getManagedResolverFactory().create({ definition, args });
-    }
-    async getAsync(identifier, args) {
-        if (typeof identifier !== 'string') {
-            identifier = this.getIdentifier(identifier);
-        }
-        if (this.registry.hasObject(identifier)) {
-            return this.registry.getObject(identifier);
-        }
-        const definition = this.registry.getDefinition(identifier);
-        if (!definition && this.parent) {
-            return this.parent.getAsync(identifier, args);
-        }
-        if (!definition) {
-            throw new notFoundError_1.NotFoundError(identifier);
-        }
-        return this.getManagedResolverFactory().createAsync({ definition, args });
-    }
-    /**
-     * proxy registry.registerObject
-     * @param {ObjectIdentifier} identifier
-     * @param target
-     */
-    registerObject(identifier, target) {
-        this.registry.registerObject(identifier, target);
-    }
-    /**
-     * register handler after instance create
-     * @param fn
-     */
-    afterEachCreated(fn) {
-        this.managedResolverFactory.afterEachCreated(fn);
-    }
-    /**
-     * register handler before instance create
-     * @param fn
-     */
-    beforeEachCreated(fn) {
-        this.managedResolverFactory.beforeEachCreated(fn);
-    }
 }
 exports.MidwayContainer = MidwayContainer;
 //# sourceMappingURL=container.js.map

package/dist/context/managed.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 用于抽象描述的属性、json、ref、set、map等内容
+ */
+import { IManagedInstance } from '@midwayjs/decorator';
+import { IObjectDefinition } from '../interface';
+import { ObjectProperties } from '../definitions/properties';
+export declare class ManagedValue implements IManagedInstance {
+    type: string;
+    value: any;
+    valueType: string;
+    constructor(value?: any, valueType?: string);
+}
+export declare class ManagedReference implements IManagedInstance {
+    type: string;
+    name: string;
+    args?: any;
+}
+export declare class ManagedJSON implements IManagedInstance {
+    type: string;
+    value: string;
+}
+export declare class ManagedList extends Array implements IManagedInstance {
+    type: string;
+}
+export declare class ManagedSet extends Set implements IManagedInstance {
+    type: string;
+}
+export declare class ManagedMap extends Map implements IManagedInstance {
+    type: string;
+}
+export declare class ManagedProperties extends ObjectProperties implements IManagedInstance {
+    type: string;
+}
+export declare class ManagedProperty implements IManagedInstance {
+    type: string;
+    name: string;
+    value: any;
+    valueType: string;
+}
+export declare class ManagedObject implements IManagedInstance {
+    type: string;
+    name: string;
+    definition: IObjectDefinition;
+}
+//# sourceMappingURL=managed.d.ts.map

package/dist/context/managed.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * 用于抽象描述的属性、json、ref、set、map等内容
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedObject = exports.ManagedProperty = exports.ManagedProperties = exports.ManagedMap = exports.ManagedSet = exports.ManagedList = exports.ManagedJSON = exports.ManagedReference = exports.ManagedValue = void 0;
+const properties_1 = require("../definitions/properties");
+const constants_1 = require("../common/constants");
+class ManagedValue {
+    constructor(value, valueType) {
+        this.type = constants_1.KEYS.VALUE_ELEMENT;
+        this.value = value;
+        this.valueType = valueType || constants_1.VALUE_TYPE.STRING;
+    }
+}
+exports.ManagedValue = ManagedValue;
+class ManagedReference {
+    constructor() {
+        this.type = constants_1.KEYS.REF_ELEMENT;
+    }
+}
+exports.ManagedReference = ManagedReference;
+class ManagedJSON {
+    constructor() {
+        this.type = constants_1.KEYS.JSON_ELEMENT;
+    }
+}
+exports.ManagedJSON = ManagedJSON;
+class ManagedList extends Array {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.KEYS.LIST_ELEMENT;
+    }
+}
+exports.ManagedList = ManagedList;
+class ManagedSet extends Set {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.KEYS.SET_ELEMENT;
+    }
+}
+exports.ManagedSet = ManagedSet;
+class ManagedMap extends Map {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.KEYS.MAP_ELEMENT;
+    }
+}
+exports.ManagedMap = ManagedMap;
+class ManagedProperties extends properties_1.ObjectProperties {
+    constructor() {
+        super(...arguments);
+        this.type = constants_1.KEYS.PROPS_ELEMENT;
+    }
+}
+exports.ManagedProperties = ManagedProperties;
+class ManagedProperty {
+    constructor() {
+        this.type = constants_1.KEYS.PROPERTY_ELEMENT;
+    }
+}
+exports.ManagedProperty = ManagedProperty;
+class ManagedObject {
+    constructor() {
+        this.type = constants_1.KEYS.OBJECT_ELEMENT;
+    }
+}
+exports.ManagedObject = ManagedObject;
+//# sourceMappingURL=managed.js.map