@midwayjs/core 3.0.0-beta.9 → 3.0.0

package/dist/baseFramework.d.ts

@@ -72,7 +72,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
      * @deprecated
      */
     protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    getMiddleware<R, N>(lastMiddleware?: CommonMiddleware<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
+    applyMiddleware<R, N>(lastMiddleware?: CommonMiddleware<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): ILogger;
     getCoreLogger(): ILogger;
     createLogger(name: string, option?: LoggerOptions): ILogger;
@@ -80,6 +80,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     getFrameworkName(): string;
     getDefaultContextLoggerClass(): any;
     useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
+    getMiddleware(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
     useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>): void;
     protected createMiddlewareManager(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
     protected createFilterManager(): FilterManager<CTX, ResOrNext, Next>;

package/dist/baseFramework.js

@@ -21,6 +21,8 @@ const loggerService_1 = require("./service/loggerService");
 const middlewareManager_1 = require("./common/middlewareManager");
 const middlewareService_1 = require("./service/middlewareService");
 const filterManager_1 = require("./common/filterManager");
+const util = require("util");
+const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
@@ -173,13 +175,13 @@ class BaseFramework {
                 return this.getApplicationContext().getAttr(key);
             },
             useMiddleware: (middleware) => {
-                this.middlewareManager.insertLast(middleware);
+                return this.useMiddleware(middleware);
             },
             getMiddleware: () => {
-                return this.middlewareManager;
+                return this.getMiddleware();
             },
             useFilter: (Filter) => {
-                this.filterManager.useFilter(Filter);
+                return this.useFilter(Filter);
             },
         };
         for (const method of whiteList) {
@@ -204,7 +206,7 @@ class BaseFramework {
      * @deprecated
      */
     async afterContainerReady(options) { }
-    async getMiddleware(lastMiddleware) {
+    async applyMiddleware(lastMiddleware) {
         if (!this.composeMiddleware) {
             this.middlewareManager.insertFirst((async (ctx, next) => {
                 let returnResult = undefined;
@@ -220,14 +222,12 @@ class BaseFramework {
                 }
                 return returnResult.result;
             }));
-            this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager);
+            debug(`[core]: Compose middleware = [${this.middlewareManager.getNames()}]`);
+            this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager, this.app);
             await this.filterManager.init(this.applicationContext);
         }
         if (lastMiddleware) {
-            return await this.middlewareService.compose([
-                this.composeMiddleware,
-                lastMiddleware,
-            ]);
+            return await this.middlewareService.compose([this.composeMiddleware, lastMiddleware], this.app);
         }
         else {
             return this.composeMiddleware;
@@ -255,8 +255,11 @@ class BaseFramework {
     useMiddleware(Middleware) {
         this.middlewareManager.insertLast(Middleware);
     }
+    getMiddleware() {
+        return this.middlewareManager;
+    }
     useFilter(Filter) {
-        this.filterManager.useFilter(Filter);
+        return this.filterManager.useFilter(Filter);
     }
     createMiddlewareManager() {
         return new middlewareManager_1.ContextMiddlewareManager();

package/dist/common/applicationManager.d.ts

@@ -0,0 +1,11 @@
+import { IMidwayApplication, IMidwayFramework } from '../interface';
+import { FrameworkType } from '@midwayjs/decorator';
+export declare class MidwayApplicationManager {
+    private globalFrameworkMap;
+    private globalFrameworkTypeMap;
+    addFramework(namespace: any, framework: IMidwayFramework<any, any, any>): void;
+    getFramework(namespaceOrFrameworkType: string | FrameworkType): IMidwayFramework<any, any, any, unknown, unknown>;
+    getApplication(namespaceOrFrameworkType: string | FrameworkType): IMidwayApplication;
+    getApplications(namespaces?: Array<string | FrameworkType>): IMidwayApplication[];
+}
+//# sourceMappingURL=applicationManager.d.ts.map

package/dist/common/applicationManager.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidwayApplicationManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+let MidwayApplicationManager = class MidwayApplicationManager {
+    constructor() {
+        this.globalFrameworkMap = new Map();
+        this.globalFrameworkTypeMap = new WeakMap();
+    }
+    addFramework(namespace, framework) {
+        this.globalFrameworkMap.set(namespace, framework);
+        this.globalFrameworkTypeMap.set(framework.getFrameworkType(), framework);
+    }
+    getFramework(namespaceOrFrameworkType) {
+        if (typeof namespaceOrFrameworkType === 'string') {
+            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkMap.get(namespaceOrFrameworkType);
+            }
+        }
+        else {
+            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkTypeMap.get(namespaceOrFrameworkType);
+            }
+        }
+    }
+    getApplication(namespaceOrFrameworkType) {
+        if (typeof namespaceOrFrameworkType === 'string') {
+            if (this.globalFrameworkMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkMap
+                    .get(namespaceOrFrameworkType)
+                    .getApplication();
+            }
+        }
+        else {
+            if (this.globalFrameworkTypeMap.has(namespaceOrFrameworkType)) {
+                return this.globalFrameworkTypeMap
+                    .get(namespaceOrFrameworkType)
+                    .getApplication();
+            }
+        }
+    }
+    getApplications(namespaces) {
+        if (!namespaces) {
+            return Array.from(this.globalFrameworkMap.values()).map(framework => {
+                return framework.getApplication();
+            });
+        }
+        else {
+            return namespaces
+                .map(namespace => {
+                return this.getApplication(namespace);
+            })
+                .filter(app => {
+                return !!app;
+            });
+        }
+    }
+};
+MidwayApplicationManager = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], MidwayApplicationManager);
+exports.MidwayApplicationManager = MidwayApplicationManager;
+//# sourceMappingURL=applicationManager.js.map

package/dist/common/dataListener.d.ts

@@ -0,0 +1,11 @@
+export declare abstract class DataListener<T> {
+    private innerData;
+    protected init(): Promise<void>;
+    abstract initData(): T;
+    abstract onData(callback: (data: T) => void): any;
+    protected setData(data: T): void;
+    getData(): T;
+    stop(): Promise<void>;
+    protected destroyListener(): Promise<void>;
+}
+//# sourceMappingURL=dataListener.d.ts.map

package/dist/common/dataListener.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataListener = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+class DataListener {
+    async init() {
+        this.innerData = await this.initData();
+        await this.onData(this.setData.bind(this));
+    }
+    setData(data) {
+        this.innerData = data;
+    }
+    getData() {
+        return this.innerData;
+    }
+    async stop() {
+        await this.destroyListener();
+    }
+    async destroyListener() { }
+}
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DataListener.prototype, "init", null);
+__decorate([
+    (0, decorator_1.Destroy)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DataListener.prototype, "stop", null);
+exports.DataListener = DataListener;
+//# sourceMappingURL=dataListener.js.map

package/dist/common/fileDetector.js

@@ -47,7 +47,7 @@ class DirectoryFileDetector extends AbstractFileDetector {
                                 continue;
                             }
                         }
-                        else if ((0, decorator_1.isRegExp)(resolveFilter.pattern)) {
+                        else if (decorator_1.Types.isRegExp(resolveFilter.pattern)) {
                             if (resolveFilter.pattern.test(file)) {
                                 const exports = resolveFilter.ignoreRequire
                                     ? undefined

package/dist/common/middlewareManager.js

@@ -151,8 +151,8 @@ class ContextMiddlewareManager extends Array {
      * @param middleware
      */
     getMiddlewareName(middleware) {
-        var _a;
-        return (_a = middleware._name) !== null && _a !== void 0 ? _a : middleware.name;
+        var _a, _b;
+        return ((_b = (_a = (middleware.getName && middleware.getName())) !== null && _a !== void 0 ? _a : middleware._name) !== null && _b !== void 0 ? _b : middleware.name);
     }
     /**
      * remove a middleware

package/dist/common/webGenerator.d.ts

@@ -1,19 +1,9 @@
-/**
- * wrap controller string to middleware function
- * @param controllerMapping like FooController.index
- * @param routeArgsInfo
- * @param routerResponseData
- */
-import { MidwayFrameworkType } from '@midwayjs/decorator';
-import { IMidwayContainer, RouterInfo } from '../index';
-import { ILogger } from '@midwayjs/logger';
+import { RouterInfo, IMidwayApplication } from '../index';
 export declare abstract class WebControllerGenerator<Router extends {
     use: (...args: any[]) => void;
 }> {
-    readonly applicationContext: IMidwayContainer;
-    readonly frameworkType: MidwayFrameworkType;
-    readonly logger?: ILogger;
-    protected constructor(applicationContext: IMidwayContainer, frameworkType: MidwayFrameworkType, logger?: ILogger);
+    readonly app: IMidwayApplication;
+    protected constructor(app: IMidwayApplication);
     /**
      * wrap controller string to middleware function
      * @param routeInfo
@@ -22,6 +12,5 @@ export declare abstract class WebControllerGenerator<Router extends {
     loadMidwayController(globalPrefix: string, routerHandler?: (newRouter: Router) => void): Promise<void>;
     abstract createRouter(routerOptions: any): Router;
     abstract generateController(routeInfo: RouterInfo): any;
-    protected handlerWebMiddleware(middlewares: any[], handlerCallback: (middlewareImpl: any) => void): Promise<void>;
 }
 //# sourceMappingURL=webGenerator.d.ts.map

package/dist/common/webGenerator.js

@@ -12,10 +12,8 @@ const index_1 = require("../index");
 const util = require("util");
 const debug = util.debuglog('midway:debug');
 class WebControllerGenerator {
-    constructor(applicationContext, frameworkType, logger) {
-        this.applicationContext = applicationContext;
-        this.frameworkType = frameworkType;
-        this.logger = logger;
+    constructor(app) {
+        this.app = app;
     }
     /**
      * wrap controller string to middleware function
@@ -65,30 +63,36 @@ class WebControllerGenerator {
         });
         const routerTable = await collector.getRouterTable();
         const routerList = await collector.getRoutePriorityList();
+        const applicationContext = this.app.getApplicationContext();
+        const logger = this.app.getCoreLogger();
+        const middlewareService = applicationContext.get(index_1.MidwayMiddlewareService);
         for (const routerInfo of routerList) {
             // bind controller first
-            this.applicationContext.bindClass(routerInfo.routerModule);
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
-            debug(`[core:webGenerator]: Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
+            applicationContext.bindClass(routerInfo.routerModule);
+            logger.debug(`Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
+            debug(`[core]: Load Controller "${routerInfo.controllerId}", prefix=${routerInfo.prefix}`);
             // new router
             const newRouter = this.createRouter({
                 prefix: routerInfo.prefix,
                 ...routerInfo.routerOptions,
             });
             // add router middleware
-            await this.handlerWebMiddleware(routerInfo.middleware, middlewareImpl => {
-                newRouter.use(middlewareImpl);
-            });
+            routerInfo.middleware = (_a = routerInfo.middleware) !== null && _a !== void 0 ? _a : [];
+            if (routerInfo.middleware.length) {
+                const routerMiddlewareFn = await middlewareService.compose(routerInfo.middleware, this.app);
+                newRouter.use(routerMiddlewareFn);
+            }
             // add route
             const routes = routerTable.get(routerInfo.prefix);
             for (const routeInfo of routes) {
                 // get middleware
-                const middlewares2 = routeInfo.middleware;
                 const methodMiddlewares = [];
-                await this.handlerWebMiddleware(middlewares2, middlewareImpl => {
-                    methodMiddlewares.push(middlewareImpl);
-                });
-                if (this.frameworkType === decorator_1.MidwayFrameworkType.WEB_KOA) {
+                routeInfo.middleware = (_b = routeInfo.middleware) !== null && _b !== void 0 ? _b : [];
+                if (routeInfo.middleware.length) {
+                    const routeMiddlewareFn = await middlewareService.compose(routeInfo.middleware, this.app);
+                    methodMiddlewares.push(routeMiddlewareFn);
+                }
+                if (this.app.getFrameworkType() === decorator_1.MidwayFrameworkType.WEB_KOA) {
                     if (typeof routeInfo.url === 'string' && /\*$/.test(routeInfo.url)) {
                         routeInfo.url = routeInfo.url.replace('*', '(.*)');
                     }
@@ -99,8 +103,8 @@ class WebControllerGenerator {
                     ...methodMiddlewares,
                     this.generateController(routeInfo),
                 ];
-                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
-                debug(`[core:webGenerator]: Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
+                logger.debug(`Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
+                debug(`[core]: Load Router "${routeInfo.requestMethod.toUpperCase()} ${routeInfo.url}"`);
                 // apply controller from request context
                 // eslint-disable-next-line prefer-spread
                 newRouter[routeInfo.requestMethod].apply(newRouter, routerArgs);
@@ -108,22 +112,6 @@ class WebControllerGenerator {
             routerHandler && routerHandler(newRouter);
         }
     }
-    async handlerWebMiddleware(middlewares, handlerCallback) {
-        if (middlewares && middlewares.length) {
-            for (const middleware of middlewares) {
-                if (typeof middleware === 'function') {
-                    // web function middleware
-                    handlerCallback(middleware);
-                }
-                else {
-                    const middlewareImpl = await this.applicationContext.getAsync(middleware);
-                    if (middlewareImpl && typeof middlewareImpl.resolve === 'function') {
-                        handlerCallback(middlewareImpl.resolve());
-                    }
-                }
-            }
-        }
-    }
 }
 exports.WebControllerGenerator = WebControllerGenerator;
 //# sourceMappingURL=webGenerator.js.map

package/dist/common/webRouterCollector.js

@@ -58,7 +58,7 @@ class WebRouterCollector {
     collectRoute(module, functionMeta = false) {
         var _a;
         const controllerId = (0, decorator_1.getProviderName)(module);
-        debug(`[core:webCollector]: Found Controller ${controllerId}.`);
+        debug(`[core]: Found Controller ${controllerId}.`);
         const id = (0, decorator_1.getProviderUUId)(module);
         const controllerOption = (0, decorator_1.getClassMetadata)(decorator_1.CONTROLLER_KEY, module);
         let priority;
@@ -232,7 +232,7 @@ class WebRouterCollector {
         return urlMatchList
             .map(item => {
             const urlString = item.url.toString();
-            const weightArr = (0, decorator_1.isRegExp)(item.url)
+            const weightArr = decorator_1.Types.isRegExp(item.url)
                 ? urlString.split('\\/')
                 : urlString.split('/');
             let weight = 0;
@@ -319,7 +319,7 @@ class WebRouterCollector {
                 item.requestMethod === routerInfo.requestMethod);
         });
         if (matched && matched.length) {
-            throw new Error(`Duplicate router "${routerInfo.requestMethod} ${routerInfo.url}" at "${matched[0].handlerName}" and "${routerInfo.handlerName}"`);
+            throw new error_1.MidwayDuplicateRouteError(`${routerInfo.requestMethod} ${routerInfo.url}`, `${matched[0].handlerName}`, `${routerInfo.handlerName}`);
         }
         prefixList.push(routerInfo);
     }

package/dist/context/container.js

@@ -144,16 +144,16 @@ class ContainerConfiguration {
     }
     getConfigurationExport(exports) {
         const mods = [];
-        if ((0, decorator_1.isClass)(exports) ||
-            (0, decorator_1.isFunction)(exports) ||
+        if (decorator_1.Types.isClass(exports) ||
+            decorator_1.Types.isFunction(exports) ||
             exports instanceof configuration_1.FunctionalConfiguration) {
             mods.push(exports);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
-                if ((0, decorator_1.isClass)(module) ||
-                    (0, decorator_1.isFunction)(module) ||
+                if (decorator_1.Types.isClass(module) ||
+                    decorator_1.Types.isFunction(module) ||
                     module instanceof configuration_1.FunctionalConfiguration) {
                     mods.push(module);
                 }
@@ -240,13 +240,13 @@ class MidwayContainer {
         (_a = this.fileDetector) === null || _a === void 0 ? void 0 : _a.run(this);
     }
     bindClass(exports, options) {
-        if ((0, decorator_1.isClass)(exports) || (0, decorator_1.isFunction)(exports)) {
+        if (decorator_1.Types.isClass(exports) || decorator_1.Types.isFunction(exports)) {
             this.bindModule(exports, options);
         }
         else {
             for (const m in exports) {
                 const module = exports[m];
-                if ((0, decorator_1.isClass)(module) || (0, decorator_1.isFunction)(module)) {
+                if (decorator_1.Types.isClass(module) || decorator_1.Types.isFunction(module)) {
                     this.bindModule(module, options);
                 }
             }
@@ -254,7 +254,7 @@ class MidwayContainer {
     }
     bind(identifier, target, options) {
         var _a;
-        if ((0, decorator_1.isClass)(identifier) || (0, decorator_1.isFunction)(identifier)) {
+        if (decorator_1.Types.isClass(identifier) || decorator_1.Types.isFunction(identifier)) {
             return this.bindModule(identifier, target);
         }
         if (this.registry.hasDefinition(identifier)) {
@@ -262,13 +262,13 @@ class MidwayContainer {
             return;
         }
         let definition;
-        if ((0, decorator_1.isClass)(target)) {
+        if (decorator_1.Types.isClass(target)) {
             definition = new objectDefinition_1.ObjectDefinition();
             definition.name = (0, decorator_1.getProviderName)(target);
         }
         else {
             definition = new functionDefinition_1.FunctionDefinition();
-            if (!(0, decorator_1.isAsyncFunction)(target)) {
+            if (!decorator_1.Types.isAsyncFunction(target)) {
                 definition.asynchronous = false;
             }
             definition.name = definition.id;
@@ -315,6 +315,10 @@ class MidwayContainer {
             debugBind(`  register scope = ${objDefOptions.scope}`);
             definition.scope = objDefOptions.scope;
         }
+        if (objDefOptions.allowDowngrade) {
+            debugBind(`  register allowDowngrade = ${objDefOptions.allowDowngrade}`);
+            definition.allowDowngrade = objDefOptions.allowDowngrade;
+        }
         this.objectCreateEventTarget.emit(interface_1.ObjectLifeCycleEvent.BEFORE_BIND, target, {
             context: this,
             definition,
@@ -327,7 +331,7 @@ class MidwayContainer {
         }
     }
     bindModule(module, options) {
-        if ((0, decorator_1.isClass)(module)) {
+        if (decorator_1.Types.isClass(module)) {
             const providerId = (0, decorator_1.getProviderUUId)(module);
             if (providerId) {
                 this.identifierMapping.saveClassRelation(module, options === null || options === void 0 ? void 0 : options.namespace);
@@ -343,7 +347,7 @@ class MidwayContainer {
                 if (!info.scope) {
                     info.scope = decorator_1.ScopeEnum.Request;
                 }
-                const uuid = (0, decorator_1.generateRandomId)();
+                const uuid = decorator_1.Utils.generateRandomId();
                 this.identifierMapping.saveFunctionRelation(info.id, uuid);
                 this.bind(uuid, module, {
                     scope: info.scope,
@@ -384,7 +388,10 @@ class MidwayContainer {
     }
     get(identifier, args, objectContext) {
         var _a;
+        args = args !== null && args !== void 0 ? args : [];
+        objectContext = objectContext !== null && objectContext !== void 0 ? objectContext : { originName: identifier };
         if (typeof identifier !== 'string') {
+            objectContext.originName = identifier.name;
             identifier = this.getIdentifier(identifier);
         }
         if (this.registry.hasObject(identifier)) {
@@ -401,7 +408,10 @@ class MidwayContainer {
     }
     async getAsync(identifier, args, objectContext) {
         var _a;
+        args = args !== null && args !== void 0 ? args : [];
+        objectContext = objectContext !== null && objectContext !== void 0 ? objectContext : { originName: identifier };
         if (typeof identifier !== 'string') {
+            objectContext.originName = identifier.name;
             identifier = this.getIdentifier(identifier);
         }
         if (this.registry.hasObject(identifier)) {

package/dist/context/managedResolverFactory.js

@@ -56,14 +56,14 @@ class ManagedResolverFactory {
     resolveManaged(managed, originPropertyName) {
         const resolver = this.resolvers[managed.type];
         if (!resolver || resolver.type !== managed.type) {
-            throw new Error(`${managed.type} resolver is not exists!`);
+            throw new error_1.MidwayResolverMissingError(managed.type);
         }
         return resolver.resolve(managed, originPropertyName);
     }
     async resolveManagedAsync(managed, originPropertyName) {
         const resolver = this.resolvers[managed.type];
         if (!resolver || resolver.type !== managed.type) {
-            throw new Error(`${managed.type} resolver is not exists!`);
+            throw new error_1.MidwayResolverMissingError(managed.type);
         }
         return resolver.resolveAsync(managed, originPropertyName);
     }
@@ -89,7 +89,7 @@ class ManagedResolverFactory {
                 this.context.get(dep, args);
             }
         }
-        debugLog(`[core:container]: Create id = "${definition.name}" ${definition.id}.`);
+        debugLog(`[core]: Create id = "${definition.name}" ${definition.id}.`);
         const Clzz = definition.creator.load();
         let constructorArgs = [];
         if (args && Array.isArray(args) && args.length > 0) {
@@ -174,7 +174,7 @@ class ManagedResolverFactory {
                 await this.context.getAsync(dep, args);
             }
         }
-        debugLog(`[core:container]: Create id = "${definition.name}" ${definition.id}.`);
+        debugLog(`[core]: Create id = "${definition.name}" ${definition.id}.`);
         const Clzz = definition.creator.load();
         let constructorArgs = [];
         if (args && Array.isArray(args) && args.length > 0) {
@@ -187,7 +187,7 @@ class ManagedResolverFactory {
         inst = await definition.creator.doConstructAsync(Clzz, constructorArgs, this.context);
         if (!inst) {
             this.removeCreateStatus(definition, false);
-            throw new Error(`${definition.id} construct return undefined`);
+            throw new error_1.MidwayCommonError(`${definition.id} construct return undefined`);
         }
         // binding ctx object
         if (definition.isRequestScope() &&
@@ -202,6 +202,13 @@ class ManagedResolverFactory {
         if (definition.properties) {
             const keys = definition.properties.propertyKeys();
             for (const key of keys) {
+                if (definition.isSingletonScope() && this.context.hasDefinition(key)) {
+                    const propertyDefinition = this.context.registry.getDefinition(key);
+                    if (propertyDefinition.isRequestScope() &&
+                        !propertyDefinition.allowDowngrade) {
+                        throw new error_1.MidwaySingletonInjectRequestError(definition.path.name, propertyDefinition.path.name);
+                    }
+                }
                 try {
                     inst[key] = await this.resolveManagedAsync(definition.properties.get(key), key);
                 }

package/dist/context/requestContainer.js

@@ -13,6 +13,8 @@ class MidwayRequestContainer extends container_1.MidwayContainer {
         this.ctx = ctx;
         // register ctx
         this.registerObject(interface_1.REQUEST_CTX_KEY, ctx);
+        // register res
+        this.registerObject('res', {});
         if (ctx.logger) {
             // register contextLogger
             this.registerObject('logger', ctx.logger);

package/dist/definitions/functionDefinition.d.ts

@@ -18,6 +18,7 @@ export declare class FunctionDefinition implements IObjectDefinition {
     asynchronous: boolean;
     handlerProps: any[];
     createFrom: any;
+    allowDowngrade: boolean;
     protected innerAutowire: boolean;
     protected innerScope: ScopeEnum;
     getAttr(key: ObjectIdentifier): any;

package/dist/definitions/functionDefinition.js

@@ -23,6 +23,7 @@ class FunctionDefinition {
         this.namespace = '';
         this.asynchronous = true;
         this.handlerProps = [];
+        this.allowDowngrade = false;
         // 函数工厂创建的对象默认不需要自动装配
         this.innerAutowire = false;
         this.innerScope = decorator_1.ScopeEnum.Singleton;

package/dist/definitions/objectCreator.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectCreator = void 0;
 const decorator_1 = require("@midwayjs/decorator");
+const error_1 = require("../error");
 class ObjectCreator {
     constructor(definition) {
         this.definition = definition;
@@ -64,7 +65,7 @@ class ObjectCreator {
         let inst;
         if (this.definition.constructMethod) {
             const fn = Clzz[this.definition.constructMethod];
-            if ((0, decorator_1.isAsyncFunction)(fn)) {
+            if (decorator_1.Types.isAsyncFunction(fn)) {
                 inst = await fn.apply(Clzz, args);
             }
             else {
@@ -85,14 +86,14 @@ class ObjectCreator {
         const inst = obj;
         // after properties set then do init
         if (this.definition.initMethod && inst[this.definition.initMethod]) {
-            if ((0, decorator_1.isGeneratorFunction)(inst[this.definition.initMethod]) ||
-                (0, decorator_1.isAsyncFunction)(inst[this.definition.initMethod])) {
-                throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
+            if (decorator_1.Types.isGeneratorFunction(inst[this.definition.initMethod]) ||
+                decorator_1.Types.isAsyncFunction(inst[this.definition.initMethod])) {
+                throw new error_1.MidwayUseWrongMethodError('context.get', 'context.getAsync', this.definition.id);
             }
             else {
                 const rt = inst[this.definition.initMethod].call(inst);
-                if ((0, decorator_1.isPromise)(rt)) {
-                    throw new Error(`${this.definition.id} not valid by context.get, Use context.getAsync instead!`);
+                if (decorator_1.Types.isPromise(rt)) {
+                    throw new error_1.MidwayUseWrongMethodError('context.get', 'context.getAsync', this.definition.id);
                 }
             }
         }
@@ -106,7 +107,7 @@ class ObjectCreator {
         const inst = obj;
         if (this.definition.initMethod && inst[this.definition.initMethod]) {
             const initFn = inst[this.definition.initMethod];
-            if ((0, decorator_1.isAsyncFunction)(initFn)) {
+            if (decorator_1.Types.isAsyncFunction(initFn)) {
                 await initFn.call(inst);
             }
             else {
@@ -139,7 +140,7 @@ class ObjectCreator {
     async doDestroyAsync(obj) {
         if (this.definition.destroyMethod && obj[this.definition.destroyMethod]) {
             const fn = obj[this.definition.destroyMethod];
-            if ((0, decorator_1.isAsyncFunction)(fn)) {
+            if (decorator_1.Types.isAsyncFunction(fn)) {
                 await fn.call(obj);
             }
             else {