@midwayjs/core 3.0.0-beta.1 → 3.0.0-beta.13

package/dist/common/middlewareManager.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextMiddlewareManager = void 0;
+class ContextMiddlewareManager extends Array {
+    /**
+     * insert a middleware or middleware array to first
+     * @param middleware
+     */
+    insertFirst(middleware) {
+        if (Array.isArray(middleware)) {
+            this.unshift(...middleware);
+        }
+        else {
+            this.unshift(middleware);
+        }
+    }
+    /**
+     * insert a middleware or middleware array to last
+     * @param middleware
+     */
+    insertLast(middleware) {
+        if (Array.isArray(middleware)) {
+            this.push(...middleware);
+        }
+        else {
+            this.push(middleware);
+        }
+    }
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrBeforeMiddleware
+     */
+    insertBefore(middleware, idxOrBeforeMiddleware) {
+        if (typeof idxOrBeforeMiddleware !== 'number') {
+            idxOrBeforeMiddleware = this.findItemIndex(idxOrBeforeMiddleware);
+        }
+        if (Array.isArray(middleware)) {
+            this.splice(idxOrBeforeMiddleware, 0, ...middleware);
+        }
+        else {
+            this.splice(idxOrBeforeMiddleware, 0, middleware);
+        }
+    }
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrAfterMiddleware
+     */
+    insertAfter(middleware, idxOrAfterMiddleware) {
+        if (typeof idxOrAfterMiddleware !== 'number') {
+            idxOrAfterMiddleware = this.findItemIndex(idxOrAfterMiddleware);
+        }
+        if (Array.isArray(middleware)) {
+            this.splice(idxOrAfterMiddleware + 1, 0, ...middleware);
+        }
+        else {
+            this.splice(idxOrAfterMiddleware + 1, 0, middleware);
+        }
+    }
+    /**
+     * move a middleware after another middleware
+     * @param middlewareOrName
+     * @param afterMiddleware
+     */
+    findAndInsertAfter(middlewareOrName, afterMiddleware) {
+        middlewareOrName = this.findItem(middlewareOrName);
+        afterMiddleware = this.findItem(afterMiddleware);
+        if (!middlewareOrName ||
+            !afterMiddleware ||
+            middlewareOrName === afterMiddleware) {
+            return;
+        }
+        if (afterMiddleware) {
+            const mw = this.remove(middlewareOrName);
+            if (mw) {
+                this.insertAfter(mw, afterMiddleware);
+            }
+        }
+    }
+    /**
+     * move a middleware before another middleware
+     * @param middlewareOrName
+     * @param beforeMiddleware
+     */
+    findAndInsertBefore(middlewareOrName, beforeMiddleware) {
+        middlewareOrName = this.findItem(middlewareOrName);
+        beforeMiddleware = this.findItem(beforeMiddleware);
+        if (!middlewareOrName ||
+            !beforeMiddleware ||
+            middlewareOrName === beforeMiddleware) {
+            return;
+        }
+        if (beforeMiddleware) {
+            const mw = this.remove(middlewareOrName);
+            if (mw) {
+                this.insertBefore(mw, beforeMiddleware);
+            }
+        }
+    }
+    /**
+     * find middleware and move to first
+     * @param middlewareOrName
+     */
+    findAndInsertFirst(middlewareOrName) {
+        const mw = this.remove(middlewareOrName);
+        if (mw) {
+            this.insertFirst(mw);
+        }
+    }
+    /**
+     * find middleware and move to last
+     * @param middlewareOrName
+     */
+    findAndInsertLast(middlewareOrName) {
+        const mw = this.remove(middlewareOrName);
+        if (mw) {
+            this.insertLast(mw);
+        }
+    }
+    /**
+     * find a middleware and return index
+     * @param middlewareOrName
+     */
+    findItemIndex(middlewareOrName) {
+        if (typeof middlewareOrName === 'number') {
+            return middlewareOrName;
+        }
+        else if (typeof middlewareOrName === 'string') {
+            return this.findIndex(item => this.getMiddlewareName(item) === middlewareOrName);
+        }
+        else {
+            return this.findIndex(item => item === middlewareOrName);
+        }
+    }
+    findItem(middlewareOrName) {
+        if (typeof middlewareOrName === 'number') {
+            if (middlewareOrName >= 0 && middlewareOrName <= this.length - 1) {
+                return this[middlewareOrName];
+            }
+        }
+        else if (typeof middlewareOrName === 'string') {
+            return this.find(item => this.getMiddlewareName(item) === middlewareOrName);
+        }
+        else {
+            return middlewareOrName;
+        }
+    }
+    /**
+     * get name from middleware
+     * @param middleware
+     */
+    getMiddlewareName(middleware) {
+        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
+     * @param middlewareOrNameOrIdx
+     */
+    remove(middlewareOrNameOrIdx) {
+        if (typeof middlewareOrNameOrIdx === 'number' &&
+            middlewareOrNameOrIdx !== -1) {
+            return this.splice(middlewareOrNameOrIdx, 1)[0];
+        }
+        else {
+            const idx = this.findItemIndex(middlewareOrNameOrIdx);
+            if (idx !== -1) {
+                return this.splice(idx, 1)[0];
+            }
+        }
+    }
+    /**
+     * get middleware name list
+     */
+    getNames() {
+        return this.map(item => {
+            return this.getMiddlewareName(item);
+        });
+    }
+}
+exports.ContextMiddlewareManager = ContextMiddlewareManager;
+//# sourceMappingURL=middlewareManager.js.map

package/dist/common/webGenerator.d.ts

@@ -0,0 +1,16 @@
+import { RouterInfo, IMidwayApplication } from '../index';
+export declare abstract class WebControllerGenerator<Router extends {
+    use: (...args: any[]) => void;
+}> {
+    readonly app: IMidwayApplication;
+    protected constructor(app: IMidwayApplication);
+    /**
+     * wrap controller string to middleware function
+     * @param routeInfo
+     */
+    generateKoaController(routeInfo: RouterInfo): (ctx: any, next: any) => Promise<void>;
+    loadMidwayController(globalPrefix: string, routerHandler?: (newRouter: Router) => void): Promise<void>;
+    abstract createRouter(routerOptions: any): Router;
+    abstract generateController(routeInfo: RouterInfo): any;
+}
+//# sourceMappingURL=webGenerator.d.ts.map

package/dist/{util → common}/webGenerator.js

@@ -8,27 +8,23 @@ exports.WebControllerGenerator = void 0;
  * @param routerResponseData
  */
 const decorator_1 = require("@midwayjs/decorator");
-const __1 = require("../");
+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;
-        this.controllerIds = [];
+    constructor(app) {
+        this.app = app;
     }
     /**
      * wrap controller string to middleware function
-     * @param controllerMapping like FooController.index
-     * @param routeArgsInfo
-     * @param routerResponseData
+     * @param routeInfo
      */
-    generateKoaController(controllerMapping, routeArgsInfo, routerResponseData) {
-        const [controllerId, methodName] = controllerMapping.split('.');
+    generateKoaController(routeInfo) {
         return async (ctx, next) => {
             const args = [ctx, next];
-            const controller = await ctx.requestContext.getAsync(controllerId);
+            const controller = await ctx.requestContext.getAsync(routeInfo.id);
             // eslint-disable-next-line prefer-spread
-            const result = await controller[methodName].apply(controller, args);
+            const result = await controller[routeInfo.method].apply(controller, args);
             if (result !== undefined) {
                 ctx.body = result;
             }
@@ -36,8 +32,9 @@ class WebControllerGenerator {
                 ctx.body = undefined;
             }
             // implement response decorator
-            if (Array.isArray(routerResponseData) && routerResponseData.length) {
-                for (const routerRes of routerResponseData) {
+            if (Array.isArray(routeInfo.responseMetadata) &&
+                routeInfo.responseMetadata.length) {
+                for (const routerRes of routeInfo.responseMetadata) {
                     switch (routerRes.type) {
                         case decorator_1.WEB_RESPONSE_HTTP_CODE:
                             ctx.status = routerRes.code;
@@ -59,40 +56,43 @@ class WebControllerGenerator {
             }
         };
     }
-    async loadMidwayController(routerHandler) {
+    async loadMidwayController(globalPrefix, routerHandler) {
         var _a, _b;
-        const collector = new __1.WebRouterCollector();
+        const collector = new index_1.WebRouterCollector('', {
+            globalPrefix,
+        });
         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);
-            const providerId = routerInfo.controllerId;
-            // controller id check
-            if (this.controllerIds.indexOf(providerId) > -1) {
-                throw new Error(`Controller identifier [${providerId}] already exists!`);
-            }
-            this.controllerIds.push(providerId);
-            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug(`Load Controller "${providerId}", 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('*', '(.*)');
                     }
@@ -101,9 +101,10 @@ class WebControllerGenerator {
                     routeInfo.routerName,
                     routeInfo.url,
                     ...methodMiddlewares,
-                    this.generateController(routeInfo.handlerName, routeInfo.requestMetadata, routeInfo.responseMetadata),
+                    this.generateController(routeInfo),
                 ];
-                (_b = this.logger) === null || _b === void 0 ? void 0 : _b.debug(`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);
@@ -111,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/{util → common}/webRouterCollector.d.ts

@@ -4,7 +4,7 @@ export interface RouterInfo {
      */
     id: string;
     /**
-     * router prefix
+     * router prefix from controller
      */
     prefix: string;
     /**
@@ -23,6 +23,9 @@ export interface RouterInfo {
      * invoke function method
      */
     method: string;
+    /**
+     * router description
+     */
     description: string;
     summary: string;
     /**
@@ -83,12 +86,12 @@ export interface RouterPriority {
 }
 export interface RouterCollectorOptions {
     includeFunctionRouter?: boolean;
+    globalPrefix?: string;
 }
 export declare class WebRouterCollector {
     protected readonly baseDir: string;
     private isReady;
     protected routes: Map<string, RouterInfo[]>;
-    protected routerModules: Set<unknown>;
     private routesPriority;
     protected options: RouterCollectorOptions;
     constructor(baseDir?: string, options?: RouterCollectorOptions);
@@ -106,7 +109,7 @@ export declare class WebRouterCollector {
          */
         id: string;
         /**
-         * router prefix
+         * router prefix from controller
          */
         prefix: string;
         /**
@@ -125,6 +128,9 @@ export declare class WebRouterCollector {
          * invoke function method
          */
         method: string;
+        /**
+         * router description
+         */
         description: string;
         summary: string;
         /**
@@ -175,7 +181,6 @@ export declare class WebRouterCollector {
     getRoutePriorityList(): Promise<RouterPriority[]>;
     getRouterTable(): Promise<Map<string, RouterInfo[]>>;
     getFlattenRouterTable(): Promise<RouterInfo[]>;
-    getRouterModules(): Promise<any[]>;
     private checkDuplicateAndPush;
 }
 //# sourceMappingURL=webRouterCollector.d.ts.map

package/dist/{util → common}/webRouterCollector.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebRouterCollector = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const index_1 = require("./index");
+const util_1 = require("../util");
 const container_1 = require("../context/container");
 const fileDetector_1 = require("./fileDetector");
 const util = require("util");
+const error_1 = require("../error");
 const debug = util.debuglog('midway:debug');
 class WebRouterCollector {
     constructor(baseDir = '', options = {}) {
         this.isReady = false;
         this.routes = new Map();
-        this.routerModules = new Set();
         this.routesPriority = [];
         this.baseDir = baseDir;
         this.options = options;
@@ -34,6 +34,17 @@ class WebRouterCollector {
                 this.collectFunctionRoute(module);
             }
         }
+        // filter empty prefix
+        this.routesPriority = this.routesPriority.filter(item => {
+            const prefixList = this.routes.get(item.prefix);
+            if (prefixList.length > 0) {
+                return true;
+            }
+            else {
+                this.routes.delete(item.prefix);
+                return false;
+            }
+        });
         // sort router
         for (const prefix of this.routes.keys()) {
             const routerInfo = this.routes.get(prefix);
@@ -41,32 +52,51 @@ class WebRouterCollector {
         }
         // sort prefix
         this.routesPriority = this.routesPriority.sort((routeA, routeB) => {
-            return routeB.priority - routeA.priority;
+            return routeB.prefix.length - routeA.prefix.length;
         });
     }
     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;
         // implement middleware in controller
         const middleware = controllerOption.routerOptions.middleware;
-        const prefix = controllerOption.prefix || '/';
-        if (prefix === '/' && priority === undefined) {
-            priority = -999;
+        const controllerIgnoreGlobalPrefix = !!((_a = controllerOption.routerOptions) === null || _a === void 0 ? void 0 : _a.ignoreGlobalPrefix);
+        let prefix = (0, util_1.joinURLPath)(this.options.globalPrefix, controllerOption.prefix || '/');
+        const ignorePrefix = controllerOption.prefix || '/';
+        // if controller set ignore global prefix, all router will be ignore too.
+        if (controllerIgnoreGlobalPrefix) {
+            prefix = ignorePrefix;
+        }
+        if (/\*/.test(prefix)) {
+            throw new error_1.MidwayCommonError(`Router prefix ${prefix} can't set string with *`);
         }
+        // set prefix
         if (!this.routes.has(prefix)) {
             this.routes.set(prefix, []);
             this.routesPriority.push({
                 prefix,
-                priority: priority || 0,
+                priority: prefix === '/' && priority === undefined ? -999 : 0,
+                middleware,
+                routerOptions: controllerOption.routerOptions,
+                controllerId,
+                routerModule: module,
+            });
+        }
+        // set ignorePrefix
+        if (!this.routes.has(ignorePrefix)) {
+            this.routes.set(ignorePrefix, []);
+            this.routesPriority.push({
+                prefix: ignorePrefix,
+                priority: ignorePrefix === '/' && priority === undefined ? -999 : 0,
                 middleware,
                 routerOptions: controllerOption.routerOptions,
                 controllerId,
                 routerModule: module,
             });
-            this.routerModules.add(module);
         }
         const webRouterInfo = (0, decorator_1.getClassMetadata)(decorator_1.WEB_ROUTER_KEY, module);
         if (webRouterInfo && typeof webRouterInfo[Symbol.iterator] === 'function') {
@@ -75,7 +105,7 @@ class WebRouterCollector {
                 const routerResponseData = (0, decorator_1.getPropertyMetadata)(decorator_1.WEB_RESPONSE_KEY, module, webRouter.method) || [];
                 const data = {
                     id,
-                    prefix,
+                    prefix: webRouter.ignoreGlobalPrefix ? ignorePrefix : prefix,
                     routerName: webRouter.routerName || '',
                     url: webRouter.path,
                     requestMethod: webRouter.requestMethod,
@@ -95,14 +125,14 @@ class WebRouterCollector {
                     data.functionName = controllerId + '-' + webRouter.method;
                     data.functionTriggerName = decorator_1.ServerlessTriggerType.HTTP;
                     data.functionTriggerMetadata = {
-                        path: (0, index_1.joinURLPath)(prefix, webRouter.path.toString()),
+                        path: (0, util_1.joinURLPath)(prefix, webRouter.path.toString()),
                         method: webRouter.requestMethod,
                     };
                     data.functionMetadata = {
                         functionName: data.functionName,
                     };
                 }
-                this.checkDuplicateAndPush(prefix, data);
+                this.checkDuplicateAndPush(data.prefix, data);
             }
         }
     }
@@ -123,7 +153,6 @@ class WebRouterCollector {
                 controllerId,
                 routerModule: module,
             });
-            this.routerModules.add(module);
         }
         for (const webRouter of webRouterInfo) {
             // 新的 @ServerlessTrigger 写法
@@ -204,12 +233,14 @@ class WebRouterCollector {
             .map(item => {
             const urlString = item.url.toString();
             const weightArr = (0, decorator_1.isRegExp)(item.url)
-                ? urlString.split('/')
+                ? urlString.split('\\/')
                 : urlString.split('/');
             let weight = 0;
             // 权重，比如通配的不加权，非通配加权，防止通配出现在最前面
             for (const fragment of weightArr) {
-                if (fragment.includes(':') || fragment.includes('*')) {
+                if (fragment === '' ||
+                    fragment.includes(':') ||
+                    fragment.includes('*')) {
                     weight += 0;
                 }
                 else {
@@ -240,12 +271,12 @@ class WebRouterCollector {
             if (handlerA._category !== handlerB._category) {
                 return handlerB._category - handlerA._category;
             }
+            // 不同权重
+            if (handlerA._weight !== handlerB._weight) {
+                return handlerB._weight - handlerA._weight;
+            }
             // 不同长度
             if (handlerA._level === handlerB._level) {
-                // 不同权重
-                if (handlerA._weight !== handlerB._weight) {
-                    return handlerB._weight - handlerA._weight;
-                }
                 if (handlerB._pureRouter === handlerA._pureRouter) {
                     return (handlerA.url.toString().length - handlerB.url.toString().length);
                 }
@@ -274,18 +305,11 @@ class WebRouterCollector {
             this.isReady = true;
         }
         let routeArr = [];
-        for (const routerInfo of this.routes.values()) {
-            routeArr = routeArr.concat(routerInfo);
+        for (const routerPriority of this.routesPriority) {
+            routeArr = routeArr.concat(this.routes.get(routerPriority.prefix));
         }
         return routeArr;
     }
-    async getRouterModules() {
-        if (!this.isReady) {
-            await this.analyze();
-            this.isReady = true;
-        }
-        return Array.from(this.routerModules);
-    }
     checkDuplicateAndPush(prefix, routerInfo) {
         const prefixList = this.routes.get(prefix);
         const matched = prefixList.filter(item => {
@@ -295,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/config/config.default.d.ts

@@ -1,21 +1,7 @@
-import { MidwayAppInfo } from '../interface';
+import { MidwayAppInfo, ServiceFactoryConfigOption } from '../interface';
+import type { LoggerOptions } from '@midwayjs/logger';
 declare const _default: (appInfo: MidwayAppInfo) => {
-    midwayLogger: {
-        default: {
-            dir: string;
-            level: string;
-            consoleLevel: string;
-        };
-        clients: {
-            coreLogger: {
-                fileLogName: string;
-            };
-            appLogger: {
-                fileLogName: string;
-                aliasName: string;
-            };
-        };
-    };
+    midwayLogger?: ServiceFactoryConfigOption<LoggerOptions>;
 };
 export default _default;
 //# sourceMappingURL=config.default.d.ts.map

package/dist/context/container.js

@@ -64,8 +64,13 @@ class ContainerConfiguration {
         });
     }
     addImportConfigs(importConfigs) {
-        if (importConfigs && importConfigs.length) {
-            this.container.get(configService_1.MidwayConfigService).add(importConfigs);
+        if (importConfigs) {
+            if (Array.isArray(importConfigs)) {
+                this.container.get(configService_1.MidwayConfigService).add(importConfigs);
+            }
+            else {
+                this.container.get(configService_1.MidwayConfigService).addObject(importConfigs);
+            }
         }
     }
     addImports(imports = []) {
@@ -379,7 +384,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)) {
@@ -396,7 +404,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)) {