@midwayjs/core 3.0.0-alpha.2 → 3.0.0-alpha.40

package/dist/context/definitionRegistry.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectDefinitionRegistry = void 0;
+/**
+ * Object Definition Registry 实现
+ */
+const decorator_1 = require("@midwayjs/decorator");
+const PREFIX = '_id_default_';
+class LegacyIdentifierRelation extends Map {
+    saveClassRelation(module, namespace) {
+        const providerId = (0, decorator_1.getProviderUUId)(module);
+        // save uuid
+        this.set(providerId, providerId);
+        if (providerId) {
+            // save alias id
+            const aliasId = (0, decorator_1.getProviderId)(module);
+            if (aliasId) {
+                // save alias Id
+                this.set(aliasId, providerId);
+            }
+            // save className alias
+            this.set((0, decorator_1.getProviderName)(module), providerId);
+            // save namespace alias
+            if (namespace) {
+                this.set(namespace + ':' + (0, decorator_1.getProviderName)(module), providerId);
+            }
+        }
+    }
+    saveFunctionRelation(id, uuid) {
+        this.set(uuid, uuid);
+        this.set(id, uuid);
+    }
+    hasRelation(id) {
+        return this.has(id);
+    }
+    getRelation(id) {
+        return this.get(id);
+    }
+}
+class ObjectDefinitionRegistry extends Map {
+    constructor() {
+        super(...arguments);
+        this.singletonIds = [];
+        this._identifierRelation = new LegacyIdentifierRelation();
+    }
+    get identifierRelation() {
+        if (!this._identifierRelation) {
+            this._identifierRelation = new LegacyIdentifierRelation();
+        }
+        return this._identifierRelation;
+    }
+    set identifierRelation(identifierRelation) {
+        this._identifierRelation = identifierRelation;
+    }
+    get identifiers() {
+        const ids = [];
+        for (const key of this.keys()) {
+            if (key.indexOf(PREFIX) === -1) {
+                ids.push(key);
+            }
+        }
+        return ids;
+    }
+    get count() {
+        return this.size;
+    }
+    getSingletonDefinitionIds() {
+        return this.singletonIds;
+    }
+    getDefinitionByName(name) {
+        const definitions = [];
+        for (const v of this.values()) {
+            const definition = v;
+            if (definition.name === name) {
+                definitions.push(definition);
+            }
+        }
+        return definitions;
+    }
+    registerDefinition(identifier, definition) {
+        if (definition.isSingletonScope()) {
+            this.singletonIds.push(identifier);
+        }
+        this.set(identifier, definition);
+    }
+    getDefinition(identifier) {
+        var _a;
+        identifier = (_a = this.identifierRelation.getRelation(identifier)) !== null && _a !== void 0 ? _a : identifier;
+        return this.get(identifier);
+    }
+    removeDefinition(identifier) {
+        this.delete(identifier);
+    }
+    hasDefinition(identifier) {
+        var _a;
+        identifier = (_a = this.identifierRelation.getRelation(identifier)) !== null && _a !== void 0 ? _a : identifier;
+        return this.has(identifier);
+    }
+    clearAll() {
+        this.singletonIds = [];
+        this.clear();
+    }
+    hasObject(identifier) {
+        var _a;
+        identifier = (_a = this.identifierRelation.getRelation(identifier)) !== null && _a !== void 0 ? _a : identifier;
+        return this.has(PREFIX + identifier);
+    }
+    registerObject(identifier, target) {
+        this.set(PREFIX + identifier, target);
+    }
+    getObject(identifier) {
+        var _a;
+        identifier = (_a = this.identifierRelation.getRelation(identifier)) !== null && _a !== void 0 ? _a : identifier;
+        return this.get(PREFIX + identifier);
+    }
+    getIdentifierRelation() {
+        return this.identifierRelation;
+    }
+    setIdentifierRelation(identifierRelation) {
+        this.identifierRelation = identifierRelation;
+    }
+}
+exports.ObjectDefinitionRegistry = ObjectDefinitionRegistry;
+//# sourceMappingURL=definitionRegistry.js.map

package/dist/context/managedResolverFactory.d.ts

@@ -1,8 +1,8 @@
 /**
  * 管理对象解析构建
  */
-import { IManagedInstance } from '@midwayjs/decorator';
-import { IApplicationContext, IManagedResolver, IObjectDefinition, IManagedResolverFactoryCreateOptions } from '../interface';
+import { IManagedInstance, ObjectIdentifier } from '@midwayjs/decorator';
+import { IManagedResolver, IObjectDefinition, IManagedResolverFactoryCreateOptions, IMidwayContainer } from '../interface';
 /**
  * 所有解析器基类
  */
@@ -13,43 +13,38 @@ export declare class BaseManagedResolver implements IManagedResolver {
     resolve(managed: IManagedInstance): any;
     resolveAsync(managed: IManagedInstance): Promise<any>;
 }
+export declare class ManagedReference implements IManagedInstance {
+    type: string;
+    name: string;
+    args?: any;
+}
 /**
  * 解析工厂
  */
 export declare class ManagedResolverFactory {
     private resolvers;
-    private _props;
     private creating;
-    singletonCache: Map<string, any>;
-    context: IApplicationContext;
+    singletonCache: Map<ObjectIdentifier, any>;
+    context: IMidwayContainer;
     afterCreateHandler: any[];
     beforeCreateHandler: any[];
-    constructor(context: IApplicationContext);
-    get props(): any;
-    /**
-     * 用于解析模版化的值
-     * example: {{aaa.bbb.ccc}}
-     * @param value 配置的模版值
-     */
-    tpl(value: any): any;
+    constructor(context: IMidwayContainer);
     registerResolver(resolver: IManagedResolver): void;
     resolveManaged(managed: IManagedInstance): any;
     resolveManagedAsync(managed: IManagedInstance): Promise<any>;
     /**
      * 同步创建对象
-     * @param definition 对象定义
-     * @param args 参数
+     * @param opt
      */
     create(opt: IManagedResolverFactoryCreateOptions): any;
     /**
      * 异步创建对象
-     * @param definition 对象定义
-     * @param args 参数
+     * @param opt
      */
     createAsync(opt: IManagedResolverFactoryCreateOptions): Promise<any>;
     destroyCache(): Promise<void>;
-    beforeEachCreated(fn: (Clzz: any, constructorArgs: [], context: IApplicationContext) => void): void;
-    afterEachCreated(fn: (ins: any, context: IApplicationContext, definition?: IObjectDefinition) => void): void;
+    beforeEachCreated(fn: (Clzz: any, constructorArgs: [], context: IMidwayContainer) => void): void;
+    afterEachCreated(fn: (ins: any, context: IMidwayContainer, definition?: IObjectDefinition) => void): void;
     /**
      * 触发单例初始化结束事件
      * @param definition 单例定义
@@ -67,6 +62,7 @@ export declare class ManagedResolverFactory {
      * 遍历依赖树判断是否循环依赖
      * @param identifier 目标id
      * @param definition 定义描述
+     * @param depth
      */
     depthFirstSearch(identifier: string, definition: IObjectDefinition, depth?: string[]): boolean;
 }

package/dist/context/managedResolverFactory.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManagedResolverFactory = exports.BaseManagedResolver = void 0;
+exports.ManagedResolverFactory = exports.ManagedReference = exports.BaseManagedResolver = void 0;
 const _ = require("../common/lodashWrap");
 const constants_1 = require("../common/constants");
 const interface_1 = require("../interface");
-const properties_1 = require("../definitions/properties");
 const notFoundError_1 = require("../common/notFoundError");
 const util = require("util");
 const debug = util.debuglog('midway:managedresolver');
@@ -26,69 +25,12 @@ class BaseManagedResolver {
     }
 }
 exports.BaseManagedResolver = BaseManagedResolver;
-/**
- * 解析json
- */
-class JSONResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.JSON_ELEMENT;
-    }
-    resolve(managed) {
-        const mjson = managed;
-        return JSON.parse(this._factory.tpl(mjson.value));
-    }
-    async resolveAsync(managed) {
-        return this.resolve(managed);
-    }
-}
-/**
- * 解析值
- */
-class ValueResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.VALUE_ELEMENT;
-    }
-    /**
-     * 解析不通类型的值
-     * @param managed 类型接口
-     * @param props 注入的属性值
-     */
-    _resolveCommon(managed) {
-        const mv = managed;
-        switch (mv.valueType) {
-            case constants_1.VALUE_TYPE.STRING:
-            case constants_1.VALUE_TYPE.TEMPLATE:
-                return this._factory.tpl(mv.value);
-            case constants_1.VALUE_TYPE.NUMBER:
-                return Number(this._factory.tpl(mv.value));
-            case constants_1.VALUE_TYPE.INTEGER:
-                return parseInt(this._factory.tpl(mv.value), 10);
-            case constants_1.VALUE_TYPE.DATE:
-                return new Date(this._factory.tpl(mv.value));
-            case constants_1.VALUE_TYPE.BOOLEAN:
-                return mv.value === 'true';
-        }
-        return mv.value;
-    }
-    resolve(managed) {
-        const mv = managed;
-        if (mv.valueType === constants_1.VALUE_TYPE.MANAGED) {
-            return this._factory.resolveManaged(mv.value);
-        }
-        else {
-            return this._resolveCommon(managed);
-        }
-    }
-    async resolveAsync(managed) {
-        const mv = managed;
-        if (mv.valueType === constants_1.VALUE_TYPE.MANAGED) {
-            return this._factory.resolveManagedAsync(mv.value);
-        }
-        else {
-            return this._resolveCommon(managed);
-        }
+class ManagedReference {
+    constructor() {
+        this.type = constants_1.KEYS.REF_ELEMENT;
     }
 }
+exports.ManagedReference = ManagedReference;
 /**
  * 解析ref
  */
@@ -105,143 +47,12 @@ class RefResolver extends BaseManagedResolver {
         return this._factory.context.getAsync(mr.name, mr.args);
     }
 }
-/**
- * 解析 list
- */
-class ListResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.LIST_ELEMENT;
-    }
-    resolve(managed) {
-        const ml = managed;
-        const arr = [];
-        for (const item of ml) {
-            arr.push(this._factory.resolveManaged(item));
-        }
-        return arr;
-    }
-    async resolveAsync(managed) {
-        const ml = managed;
-        const arr = [];
-        for (const item of ml) {
-            arr.push(await this._factory.resolveManagedAsync(item));
-        }
-        return arr;
-    }
-}
-/**
- * 解析set
- */
-class SetResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.SET_ELEMENT;
-    }
-    resolve(managed) {
-        const ms = managed;
-        const s = new Set();
-        for (const item of ms) {
-            s.add(this._factory.resolveManaged(item));
-        }
-        return s;
-    }
-    async resolveAsync(managed) {
-        const ms = managed;
-        const s = new Set();
-        for (const item of ms) {
-            s.add(await this._factory.resolveManagedAsync(item));
-        }
-        return s;
-    }
-}
-/**
- * 解析map
- */
-class MapResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.MAP_ELEMENT;
-    }
-    resolve(managed) {
-        const mm = managed;
-        const m = new Map();
-        for (const key of mm.keys()) {
-            m.set(key, this._factory.resolveManaged(mm.get(key)));
-        }
-        return m;
-    }
-    async resolveAsync(managed) {
-        const mm = managed;
-        const m = new Map();
-        for (const key of mm.keys()) {
-            m.set(key, await this._factory.resolveManagedAsync(mm.get(key)));
-        }
-        return m;
-    }
-}
-/**
- * 解析properties
- */
-class PropertiesResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.PROPS_ELEMENT;
-    }
-    resolve(managed) {
-        const m = managed;
-        const cfg = new properties_1.ObjectProperties();
-        const keys = m.keys();
-        for (const key of keys) {
-            cfg.setProperty(key, this._factory.resolveManaged(m.getProperty(key)));
-        }
-        return cfg;
-    }
-    async resolveAsync(managed) {
-        const m = managed;
-        const cfg = new properties_1.ObjectProperties();
-        const keys = m.keys();
-        for (const key of keys) {
-            cfg.setProperty(key, await this._factory.resolveManagedAsync(m.getProperty(key)));
-        }
-        return cfg;
-    }
-}
-/**
- * 解析property
- */
-class PropertyResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.PROPERTY_ELEMENT;
-    }
-    resolve(managed) {
-        const mp = managed;
-        return this._factory.resolveManaged(mp.value);
-    }
-    async resolveAsync(managed) {
-        const mp = managed;
-        return this._factory.resolveManagedAsync(mp.value);
-    }
-}
-/**
- * 解析 object
- */
-class ObjectResolver extends BaseManagedResolver {
-    get type() {
-        return constants_1.KEYS.OBJECT_ELEMENT;
-    }
-    resolve(managed) {
-        const mo = managed;
-        return this._factory.create({ definition: mo.definition });
-    }
-    async resolveAsync(managed) {
-        const mo = managed;
-        return this._factory.createAsync({ definition: mo.definition });
-    }
-}
 /**
  * 解析工厂
  */
 class ManagedResolverFactory {
     constructor(context) {
         this.resolvers = {};
-        this._props = null;
         this.creating = new Map();
         this.singletonCache = new Map();
         this.afterCreateHandler = [];
@@ -249,37 +60,9 @@ class ManagedResolverFactory {
         this.context = context;
         // 初始化解析器
         this.resolvers = {
-            json: new JSONResolver(this),
-            value: new ValueResolver(this),
-            list: new ListResolver(this),
-            set: new SetResolver(this),
-            map: new MapResolver(this),
-            props: new PropertiesResolver(this),
-            property: new PropertyResolver(this),
-            object: new ObjectResolver(this),
             ref: new RefResolver(this),
         };
     }
-    get props() {
-        if (!this._props) {
-            this._props = this.context.props.toJSON();
-        }
-        return this._props;
-    }
-    /**
-     * 用于解析模版化的值
-     * example: {{aaa.bbb.ccc}}
-     * @param value 配置的模版值
-     */
-    tpl(value) {
-        if (typeof value === 'string' && value.indexOf('{{') > -1) {
-            return _.template(value, {
-                // use `{{` and `}}` as delimiters
-                interpolate: /{{([\s\S]+?)}}/g,
-            })(this.props);
-        }
-        return value;
-    }
     registerResolver(resolver) {
         this.resolvers[resolver.type] = resolver;
     }
@@ -299,8 +82,7 @@ class ManagedResolverFactory {
     }
     /**
      * 同步创建对象
-     * @param definition 对象定义
-     * @param args 参数
+     * @param opt
      */
     create(opt) {
         const { definition, args } = opt;
@@ -325,13 +107,6 @@ class ManagedResolverFactory {
         if (args && _.isArray(args) && args.length > 0) {
             constructorArgs = args;
         }
-        else {
-            if (definition.constructorArgs) {
-                for (const arg of definition.constructorArgs) {
-                    constructorArgs.push(this.resolveManaged(arg));
-                }
-            }
-        }
         for (const handler of this.beforeCreateHandler) {
             handler.call(this, Clzz, constructorArgs, this.context);
         }
@@ -348,9 +123,8 @@ class ManagedResolverFactory {
         if (definition.properties) {
             const keys = definition.properties.keys();
             for (const key of keys) {
-                const identifier = definition.properties.getProperty(key);
                 try {
-                    inst[key] = this.resolveManaged(identifier);
+                    inst[key] = this.resolveManaged(definition.properties.get(key));
                 }
                 catch (error) {
                     if (notFoundError_1.NotFoundError.isClosePrototypeOf(error)) {
@@ -379,8 +153,7 @@ class ManagedResolverFactory {
     }
     /**
      * 异步创建对象
-     * @param definition 对象定义
-     * @param args 参数
+     * @param opt
      */
     async createAsync(opt) {
         const { definition, args } = opt;
@@ -404,19 +177,10 @@ class ManagedResolverFactory {
             }
         }
         const Clzz = definition.creator.load();
-        let constructorArgs;
+        let constructorArgs = [];
         if (args && _.isArray(args) && args.length > 0) {
             constructorArgs = args;
         }
-        else {
-            if (definition.constructorArgs) {
-                constructorArgs = [];
-                for (const arg of definition.constructorArgs) {
-                    debug('id = %s resolve constructor arg %s.', definition.id, arg);
-                    constructorArgs.push(await this.resolveManagedAsync(arg));
-                }
-            }
-        }
         for (const handler of this.beforeCreateHandler) {
             handler.call(this, Clzz, constructorArgs, this.context);
         }
@@ -438,10 +202,8 @@ class ManagedResolverFactory {
         if (definition.properties) {
             const keys = definition.properties.keys();
             for (const key of keys) {
-                const identifier = definition.properties.getProperty(key);
                 try {
-                    debug('id = %s resolve property key = %s => %s.', definition.id, key, identifier);
-                    inst[key] = await this.resolveManagedAsync(identifier);
+                    inst[key] = await this.resolveManagedAsync(definition.properties.get(key));
                 }
                 catch (error) {
                     if (notFoundError_1.NotFoundError.isClosePrototypeOf(error)) {
@@ -548,17 +310,25 @@ class ManagedResolverFactory {
      * 遍历依赖树判断是否循环依赖
      * @param identifier 目标id
      * @param definition 定义描述
+     * @param depth
      */
     depthFirstSearch(identifier, definition, depth) {
+        var _a;
         if (definition) {
             debug('dfs for %s == %s start.', identifier, definition.id);
-            if (definition.constructorArgs) {
-                const args = definition.constructorArgs.map(val => val.name);
-                if (args.indexOf(identifier) > -1) {
-                    debug('dfs exist in constructor %s == %s.', identifier, definition.id);
-                    return true;
-                }
-            }
+            // if (definition.constructorArgs) {
+            //   const args = definition.constructorArgs.map(
+            //     val => (val as ManagedReference).name
+            //   );
+            //   if (args.indexOf(identifier) > -1) {
+            //     debug(
+            //       'dfs exist in constructor %s == %s.',
+            //       identifier,
+            //       definition.id
+            //     );
+            //     return true;
+            //   }
+            // }
             if (definition.properties) {
                 const keys = definition.properties.keys();
                 if (keys.indexOf(identifier) > -1) {
@@ -572,7 +342,8 @@ class ManagedResolverFactory {
                     let iden = key;
                     const ref = definition.properties.get(key);
                     if (ref && ref.name) {
-                        iden = ref.name;
+                        iden =
+                            (_a = this.context.identifierMapping.getRelation(ref.name)) !== null && _a !== void 0 ? _a : ref.name;
                     }
                     if (iden === identifier) {
                         debug('dfs exist in properties key %s == %s.', identifier, definition.id);

package/dist/context/providerWrapper.d.ts

@@ -1,9 +1,8 @@
 import { ObjectIdentifier, ScopeEnum } from '@midwayjs/decorator';
-import { IApplicationContext } from '../interface';
+import { IMidwayContainer } from '../interface';
 export declare function providerWrapper(wrapperInfo: Array<{
     id: ObjectIdentifier;
-    provider: (context: IApplicationContext, args?: any) => any;
+    provider: (context: IMidwayContainer, args?: any) => any;
     scope?: ScopeEnum;
-    isAutowire?: boolean;
 }>): void;
 //# sourceMappingURL=providerWrapper.d.ts.map

package/dist/context/requestContainer.d.ts

@@ -1,9 +1,8 @@
 import { MidwayContainer } from './container';
 import { IMidwayContainer } from '../interface';
 export declare class MidwayRequestContainer extends MidwayContainer {
-    private applicationContext;
+    private readonly applicationContext;
     constructor(ctx: any, applicationContext: IMidwayContainer);
-    protected createContainerIdx(): number;
     init(): void;
     get<T = any>(identifier: any, args?: any): T;
     getAsync<T = any>(identifier: any, args?: any): Promise<T>;

package/dist/context/requestContainer.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MidwayRequestContainer = void 0;
 const container_1 = require("./container");
 const interface_1 = require("../interface");
-const util_1 = require("../util/");
 const decorator_1 = require("@midwayjs/decorator");
 class MidwayRequestContainer extends container_1.MidwayContainer {
     constructor(ctx, applicationContext) {
-        super(null, applicationContext);
+        super(applicationContext);
         this.applicationContext = applicationContext;
         this.configService = this.applicationContext.getConfigService();
         this.environmentService = this.applicationContext.getEnvironmentService();
         this.aspectService = this.applicationContext.getAspectService();
+        // update legacy relationship
+        this.registry.setIdentifierRelation(this.applicationContext.registry.getIdentifierRelation());
         this.ctx = ctx;
         // register ctx
         this.registerObject(interface_1.REQUEST_CTX_KEY, ctx);
@@ -23,10 +24,6 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
         this.beforeEachCreated(resolverHandler.beforeEachCreated.bind(resolverHandler));
         this.afterEachCreated(resolverHandler.afterEachCreated.bind(resolverHandler));
     }
-    createContainerIdx() {
-        // requestContainer id = -1；
-        return -1;
-    }
     init() {
         // do nothing
     }
@@ -35,8 +32,7 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
             identifier = this.getIdentifier(identifier);
         }
         if (this.registry.hasObject(identifier)) {
-            const ins = this.registry.getObject(identifier);
-            return this.aspectService.wrapperAspectToInstance(ins);
+            return this.findRegisterObject(identifier);
         }
         const definition = this.applicationContext.registry.getDefinition(identifier);
         if (definition) {
@@ -58,10 +54,8 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
         if (typeof identifier !== 'string') {
             identifier = this.getIdentifier(identifier);
         }
-        identifier = util_1.parsePrefix(identifier);
         if (this.registry.hasObject(identifier)) {
-            const ins = this.registry.getObject(identifier);
-            return this.aspectService.wrapperAspectToInstance(ins);
+            return this.findRegisterObject(identifier);
         }
         const definition = this.applicationContext.registry.getDefinition(identifier);
         if (definition) {
@@ -80,7 +74,6 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
         }
     }
     async ready() {
-        this.readied = true;
         // ignore other things
     }
     getConfigService() {

package/dist/context/resolverHandler.d.ts

@@ -1,9 +1,9 @@
 import { ManagedResolverFactory } from './managedResolverFactory';
-import { HandlerFunction, IResolverHandler, IObjectDefinition, IApplicationContext } from '../interface';
+import { HandlerFunction, IResolverHandler, IObjectDefinition, IMidwayContainer } from '../interface';
 export declare class ResolverHandler implements IResolverHandler {
     private handlerMap;
     private resolverFactory;
-    constructor(container: IApplicationContext, factory: ManagedResolverFactory);
+    constructor(container: IMidwayContainer, factory: ManagedResolverFactory);
     bindCreatedHook(): void;
     /**
      * 创建对象前
@@ -28,6 +28,7 @@ export declare class ResolverHandler implements IResolverHandler {
      */
     private defineGetterPropertyValue;
     registerHandler(key: string, fn: HandlerFunction): void;
+    hasHandler(key: string): boolean;
     getHandler(key: string): HandlerFunction;
 }
 //# sourceMappingURL=resolverHandler.d.ts.map