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

package/dist/baseFramework.js

@@ -107,6 +107,16 @@ class BaseFramework {
         await this.initializeLogger(options);
     }
     async containerDirectoryLoad(options) {
+        if (options.applicationContext) {
+            // 如果有传入全局容器，就不需要再次扫描了
+            return;
+        }
+        // 废弃 deprecated
+        if (options.preloadModules && options.preloadModules.length) {
+            for (const preloadModule of options.preloadModules) {
+                this.applicationContext.bindClass(preloadModule);
+            }
+        }
         // register app
         this.applicationContext.registerDataHandler(decorator_1.APPLICATION_KEY, (key, meta) => {
             var _a;
@@ -271,7 +281,7 @@ class BaseFramework {
             }
             else {
                 // 普通类写法
-                const providerId = (0, decorator_1.getProviderUUId)(cycle.target);
+                const providerId = (0, decorator_1.getProviderId)(cycle.target);
                 if (this.getApplicationContext().registry.hasDefinition(providerId)) {
                     cycle.instance =
                         await this.getApplicationContext().getAsync(providerId);
@@ -290,7 +300,22 @@ class BaseFramework {
         }
         for (const cycle of lifecycleInstanceList) {
             if (typeof cycle.instance.onReady === 'function') {
-                await cycle.instance.onReady(this.getApplicationContext(), this.app);
+                /**
+                 * 让组件能正确获取到 bind 之后 registerObject 的对象有三个方法
+                 * 1、在 load 之后修改 bind，不太可行
+                 * 2、每次 getAsync 的时候，去掉 namespace，同时还要查找当前全局的变量，性能差
+                 * 3、一般只会在 onReady 的地方执行 registerObject（否则没有全局的意义），这个取巧的办法就是 onReady 传入一个代理，其中绑定当前的 namespace
+                 */
+                await cycle.instance.onReady(new Proxy(this.getApplicationContext(), {
+                    get: function (target, prop, receiver) {
+                        if (prop === 'getCurrentNamespace' && cycle.namespace) {
+                            return () => {
+                                return cycle.namespace;
+                            };
+                        }
+                        return Reflect.get(target, prop, receiver);
+                    },
+                }), this.app);
             }
         }
     }
@@ -303,11 +328,20 @@ class BaseFramework {
                 inst = cycle.target;
             }
             else {
-                const providerId = (0, decorator_1.getProviderUUId)(cycle.target);
+                const providerId = (0, decorator_1.getProviderId)(cycle.target);
                 inst = await this.applicationContext.getAsync(providerId);
             }
             if (inst.onStop && typeof inst.onStop === 'function') {
-                await inst.onStop(this.getApplicationContext(), this.app);
+                await inst.onStop(new Proxy(this.getApplicationContext(), {
+                    get: function (target, prop, receiver) {
+                        if (prop === 'getCurrentNamespace' && cycle.namespace) {
+                            return () => {
+                                return cycle.namespace;
+                            };
+                        }
+                        return Reflect.get(target, prop, receiver);
+                    },
+                }), this.app);
             }
         }
     }

package/dist/common/reflectTool.d.ts

@@ -1,7 +1,5 @@
 import 'reflect-metadata';
-export interface ReflectResult {
-    [key: string]: any[];
-}
+import { ReflectResult } from '@midwayjs/decorator';
 /**
  * 以数组形式返回对象所有 property, 数组第一个元素是距离 o 最近的原型
  * @param target 对象，class 或者 function

package/dist/context/applicationContext.d.ts

@@ -0,0 +1,81 @@
+/**
+ * 基础的ObjectFactory和ApplicationContext实现
+ */
+import { ObjectIdentifier } from '@midwayjs/decorator';
+import { IApplicationContext, IObjectDefinition, IObjectDefinitionRegistry, IObjectFactory, ObjectDependencyTree } from '../interface';
+import { ObjectProperties } from '../definitions/properties';
+import { ManagedResolverFactory } from './managedResolverFactory';
+export declare class ObjectDefinitionRegistry extends Map implements IObjectDefinitionRegistry {
+    private singletonIds;
+    get identifiers(): any[];
+    get count(): number;
+    getSingletonDefinitionIds(): ObjectIdentifier[];
+    getDefinitionByName(name: string): IObjectDefinition[];
+    registerDefinition(identifier: ObjectIdentifier, definition: IObjectDefinition): void;
+    getDefinition(identifier: ObjectIdentifier): IObjectDefinition;
+    getDefinitionByPath(path: string): IObjectDefinition;
+    removeDefinition(identifier: ObjectIdentifier): void;
+    hasDefinition(identifier: ObjectIdentifier): boolean;
+    clearAll(): void;
+    hasObject(identifier: ObjectIdentifier): boolean;
+    registerObject(identifier: ObjectIdentifier, target: any): void;
+    getObject(identifier: ObjectIdentifier): any;
+}
+export declare class BaseApplicationContext implements IApplicationContext, IObjectFactory {
+    protected readied: boolean;
+    protected midwayIdentifiers: string[];
+    private _resolverFactory;
+    private _registry;
+    private _props;
+    private _dependencyMap;
+    baseDir: string;
+    parent: IApplicationContext;
+    disableConflictCheck: boolean;
+    constructor(baseDir?: string, parent?: IApplicationContext);
+    get dependencyMap(): Map<string, ObjectDependencyTree>;
+    get props(): ObjectProperties;
+    get registry(): IObjectDefinitionRegistry;
+    set registry(registry: IObjectDefinitionRegistry);
+    protected getManagedResolverFactory(): ManagedResolverFactory;
+    /**
+     * 继承实现时需要调用super
+     */
+    protected init(): void;
+    stop(): Promise<void>;
+    ready(): void;
+    protected loadDefinitions(): void;
+    isAsync(identifier: ObjectIdentifier): boolean;
+    get<T>(identifier: {
+        new (...args: any[]): T;
+    }, args?: any): T;
+    get<T>(identifier: ObjectIdentifier, args?: any): T;
+    getAsync<T>(identifier: {
+        new (...args: any[]): T;
+    }, args?: any): Promise<T>;
+    getAsync<T>(identifier: ObjectIdentifier, args?: any): Promise<T>;
+    get isReady(): boolean;
+    /**
+     * proxy registry.registerDefinition
+     * @param {ObjectIdentifier} identifier
+     * @param {IObjectDefinition} definition
+     */
+    registerDefinition(identifier: ObjectIdentifier, definition: IObjectDefinition): void;
+    /**
+     * proxy registry.registerObject
+     * @param {ObjectIdentifier} identifier
+     * @param target
+     */
+    registerObject(identifier: ObjectIdentifier, target: any): void;
+    /**
+     * register handler after instance create
+     * @param fn
+     */
+    afterEachCreated(fn: (ins: any, context: IApplicationContext, definition?: IObjectDefinition) => void): void;
+    /**
+     * register handler before instance create
+     * @param fn
+     */
+    beforeEachCreated(fn: (Clzz: any, constructorArgs: any[], context: IApplicationContext) => void): void;
+    protected createObjectDependencyTree(identifier: any, definition: any): void;
+}
+//# sourceMappingURL=applicationContext.d.ts.map

package/dist/context/applicationContext.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseApplicationContext = exports.ObjectDefinitionRegistry = void 0;
+/**
+ * 基础的ObjectFactory和ApplicationContext实现
+ */
+const decorator_1 = require("@midwayjs/decorator");
+const properties_1 = require("../definitions/properties");
+const managedResolverFactory_1 = require("./managedResolverFactory");
+const notFoundError_1 = require("../common/notFoundError");
+const util_1 = require("../util/");
+const pathFileUtil_1 = require("../util/pathFileUtil");
+const PREFIX = '_id_default_';
+class ObjectDefinitionRegistry extends Map {
+    constructor() {
+        super(...arguments);
+        this.singletonIds = [];
+    }
+    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) {
+        return this.get(identifier);
+    }
+    getDefinitionByPath(path) {
+        for (const v of this.values()) {
+            const definition = v;
+            if (definition.path === path) {
+                return definition;
+            }
+        }
+        return null;
+    }
+    removeDefinition(identifier) {
+        this.delete(identifier);
+    }
+    hasDefinition(identifier) {
+        return this.has(identifier);
+    }
+    clearAll() {
+        this.singletonIds = [];
+        this.clear();
+    }
+    hasObject(identifier) {
+        return this.has(PREFIX + identifier);
+    }
+    registerObject(identifier, target) {
+        this.set(PREFIX + identifier, target);
+    }
+    getObject(identifier) {
+        return this.get(PREFIX + identifier);
+    }
+}
+exports.ObjectDefinitionRegistry = ObjectDefinitionRegistry;
+class BaseApplicationContext {
+    constructor(baseDir = '', parent) {
+        this.readied = false;
+        // 自己内部实现的，可注入的 feature(见 features)
+        this.midwayIdentifiers = [];
+        this._resolverFactory = null;
+        this._registry = null;
+        this._props = null;
+        this._dependencyMap = null;
+        this.baseDir = null;
+        this.parent = null;
+        this.disableConflictCheck = false;
+        this.parent = parent;
+        this.baseDir = baseDir;
+        this.init();
+    }
+    get dependencyMap() {
+        if (!this._dependencyMap) {
+            this._dependencyMap = new Map();
+        }
+        return this._dependencyMap;
+    }
+    get props() {
+        if (!this._props) {
+            this._props = new properties_1.ObjectProperties();
+        }
+        return this._props;
+    }
+    get registry() {
+        if (!this._registry) {
+            this._registry = new ObjectDefinitionRegistry();
+        }
+        return this._registry;
+    }
+    set registry(registry) {
+        this._registry = registry;
+    }
+    getManagedResolverFactory() {
+        if (!this._resolverFactory) {
+            this._resolverFactory = new managedResolverFactory_1.ManagedResolverFactory(this);
+        }
+        return this._resolverFactory;
+    }
+    /**
+     * 继承实现时需要调用super
+     */
+    init() { }
+    async stop() {
+        await this.getManagedResolverFactory().destroyCache();
+        this.registry.clearAll();
+        this.readied = false;
+    }
+    ready() {
+        this.loadDefinitions();
+        this.readied = true;
+    }
+    loadDefinitions() { }
+    isAsync(identifier) {
+        if (this.registry.hasDefinition(identifier)) {
+            return this.registry.getDefinition(identifier).isAsync();
+        }
+        return false;
+    }
+    get(identifier, args) {
+        if (!this.readied) {
+            this.ready();
+        }
+        if (typeof identifier !== 'string') {
+            identifier = (0, decorator_1.getProviderId)(identifier);
+        }
+        // 因为在这里拿不到类名, NotFoundError 类的错误信息在 ManagedResolverFactory.ts createAsync 方法中增加错误类名
+        identifier = (0, util_1.parsePrefix)(identifier);
+        if (this.registry.hasObject(identifier)) {
+            return this.registry.getObject(identifier);
+        }
+        if (this.isAsync(identifier)) {
+            throw new Error(`${identifier} must use getAsync`);
+        }
+        const definition = this.registry.getDefinition(identifier);
+        if (!definition && this.parent) {
+            if (this.parent.isAsync(identifier)) {
+                throw new Error(`${identifier} must use getAsync`);
+            }
+            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 (!this.readied) {
+            this.ready();
+        }
+        if (typeof identifier !== 'string') {
+            identifier = (0, decorator_1.getProviderId)(identifier);
+        }
+        // 因为在这里拿不到类名, NotFoundError 类的错误信息在 ManagedResolverFactory.ts createAsync 方法中增加错误类名
+        identifier = (0, util_1.parsePrefix)(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 });
+    }
+    get isReady() {
+        return this.readied;
+    }
+    /**
+     * proxy registry.registerDefinition
+     * @param {ObjectIdentifier} identifier
+     * @param {IObjectDefinition} definition
+     */
+    registerDefinition(identifier, definition) {
+        if (!this.disableConflictCheck && this.registry.hasDefinition(identifier)) {
+            const def = this.registry.getDefinition(identifier);
+            if (definition.srcPath && def.srcPath) {
+                if (!pathFileUtil_1.PathFileUtil.isPathEqual(definition.srcPath, def.srcPath)) {
+                    throw new Error(`${identifier} path = ${definition.srcPath} already exist (${def.srcPath})!`);
+                }
+            }
+        }
+        this.registry.registerDefinition(identifier, definition);
+        this.createObjectDependencyTree(identifier, definition);
+    }
+    /**
+     * 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.getManagedResolverFactory().afterEachCreated(fn);
+    }
+    /**
+     * register handler before instance create
+     * @param fn
+     */
+    beforeEachCreated(fn) {
+        this.getManagedResolverFactory().beforeEachCreated(fn);
+    }
+    createObjectDependencyTree(identifier, definition) {
+        if (!this.dependencyMap.has(identifier)) {
+            let constructorArgs = definition.constructorArgs || [];
+            constructorArgs = constructorArgs
+                .map(ref => {
+                return ref.name;
+            })
+                .filter(name => {
+                return !!name;
+            });
+            const properties = (definition.properties &&
+                definition.properties.keys().map(key => {
+                    return definition.properties.get(key).name;
+                })) ||
+                [];
+            this.dependencyMap.set(identifier, {
+                name: typeof definition.path !== 'string'
+                    ? definition.path.name
+                    : identifier,
+                scope: definition.scope,
+                constructorArgs,
+                properties,
+            });
+        }
+    }
+}
+exports.BaseApplicationContext = BaseApplicationContext;
+//# sourceMappingURL=applicationContext.js.map

package/dist/context/container.d.ts

@@ -1,15 +1,22 @@
 /// <reference types="node" />
 import { ObjectDefinitionOptions, ObjectIdentifier } from '@midwayjs/decorator';
 import * as util from 'util';
-import { IConfigService, IEnvironmentService, IFileDetector, IIdentifierRelationShip, IInformationService, IMidwayContainer, IObjectDefinition, IObjectDefinitionRegistry } from '../interface';
+import { BaseApplicationContext } from './applicationContext';
+import { IConfigService, IEnvironmentService, IFileDetector, IInformationService, IMidwayContainer, IObjectDefinitionMetadata } from '../interface';
 import { ResolverHandler } from './resolverHandler';
-import { ManagedResolverFactory } from './managedResolverFactory';
-export declare class MidwayContainer implements IMidwayContainer {
-    private _resolverFactory;
-    private _registry;
-    private _identifierMapping;
-    parent: IMidwayContainer;
+declare class ContainerConfiguration {
+    readonly container: any;
+    private namespace;
+    constructor(container: any);
+    load(module: any): void;
+    addImportConfigs(importConfigs: string[]): void;
+    addImports(imports?: any[]): void;
+    bindConfigurationClass(clzz: any, filePath?: string): void;
+    private getConfigurationExport;
+}
+export declare class MidwayContainer extends BaseApplicationContext implements IMidwayContainer {
     private debugLogger;
+    private definitionMetadataList;
     protected resolverHandler: ResolverHandler;
     protected ctx: {};
     protected configService: IConfigService;
@@ -19,19 +26,18 @@ export declare class MidwayContainer implements IMidwayContainer {
     private fileDetector;
     private attrMap;
     private isLoad;
-    constructor(parent?: IMidwayContainer);
-    protected init(): void;
-    get registry(): IObjectDefinitionRegistry;
-    set registry(registry: IObjectDefinitionRegistry);
-    get managedResolverFactory(): ManagedResolverFactory;
-    get identifierMapping(): IIdentifierRelationShip;
-    protected initService(): void;
+    init(): void;
+    initService(): void;
     load(module?: any): void;
-    protected loadDefinitions(): void;
+    loadDefinitions(): void;
+    createConfiguration(): ContainerConfiguration;
     bindClass(exports: any, namespace?: string, filePath?: string): void;
     bind<T>(target: T, options?: ObjectDefinitionOptions): void;
     bind<T>(identifier: ObjectIdentifier, target: T, options?: ObjectDefinitionOptions): void;
-    protected bindModule(module: any, options?: ObjectDefinitionOptions): void;
+    protected restoreDefinition(definitionMeta: IObjectDefinitionMetadata): void;
+    protected restoreDefinitions(definitionMetadataList: any): void;
+    protected getDefinitionMetaList(): any[];
+    protected bindModule(module: any, namespace?: string, filePath?: string): void;
     getDebugLogger(): util.DebugLogger;
     setFileDetector(fileDetector: IFileDetector): void;
     createChild(): IMidwayContainer;
@@ -45,34 +51,6 @@ export declare class MidwayContainer implements IMidwayContainer {
     getResolverHandler(): ResolverHandler;
     setAttr(key: string, value: any): void;
     getAttr<T>(key: string): T;
-    protected getIdentifier(target: any): string;
-    protected findRegisterObject(identifier: any): any;
-    protected getManagedResolverFactory(): ManagedResolverFactory;
-    stop(): Promise<void>;
-    ready(): Promise<void>;
-    get<T>(identifier: {
-        new (...args: any[]): T;
-    }, args?: any): T;
-    get<T>(identifier: ObjectIdentifier, args?: any): T;
-    getAsync<T>(identifier: {
-        new (...args: any[]): T;
-    }, args?: any): Promise<T>;
-    getAsync<T>(identifier: ObjectIdentifier, args?: any): Promise<T>;
-    /**
-     * proxy registry.registerObject
-     * @param {ObjectIdentifier} identifier
-     * @param target
-     */
-    registerObject(identifier: ObjectIdentifier, target: any): void;
-    /**
-     * register handler after instance create
-     * @param fn
-     */
-    afterEachCreated(fn: (ins: any, context: IMidwayContainer, definition?: IObjectDefinition) => void): void;
-    /**
-     * register handler before instance create
-     * @param fn
-     */
-    beforeEachCreated(fn: (Clzz: any, constructorArgs: any[], context: IMidwayContainer) => void): void;
 }
+export {};
 //# sourceMappingURL=container.d.ts.map