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

package/CHANGELOG.md

@@ -3,6 +3,112 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.0.0-beta.10](https://github.com/midwayjs/midway/compare/v3.0.0-beta.9...v3.0.0-beta.10) (2021-12-20)
+
+
+### Features
+
+* default add session  & bodyparser support for koa/express/faas ([#1420](https://github.com/midwayjs/midway/issues/1420)) ([cdaff31](https://github.com/midwayjs/midway/commit/cdaff317c3e862a95494a167995a28280af639bf))
+* implement i18n for validate ([#1426](https://github.com/midwayjs/midway/issues/1426)) ([4c7ed2f](https://github.com/midwayjs/midway/commit/4c7ed2ff2e7ccf10f88f62abad230f92f5e76b97))
+
+
+
+
+
+# [3.0.0-beta.9](https://github.com/midwayjs/midway/compare/v3.0.0-beta.8...v3.0.0-beta.9) (2021-12-09)
+
+
+### Bug Fixes
+
+* faas missing config in framework ([#1413](https://github.com/midwayjs/midway/issues/1413)) ([7ab16a2](https://github.com/midwayjs/midway/commit/7ab16a24b29d5254a762bfffcdf18385effdf639))
+
+
+
+
+
+# [3.0.0-beta.8](https://github.com/midwayjs/midway/compare/v3.0.0-beta.7...v3.0.0-beta.8) (2021-12-08)
+
+
+### Bug Fixes
+
+* express routing middleware takes effect at the controller level ([#1364](https://github.com/midwayjs/midway/issues/1364)) ([b9272e0](https://github.com/midwayjs/midway/commit/b9272e0971003443304b0c53815be31a0061b4bd))
+
+
+
+
+
+# [3.0.0-beta.7](https://github.com/midwayjs/midway/compare/v3.0.0-beta.6...v3.0.0-beta.7) (2021-12-03)
+
+
+### Bug Fixes
+
+* add app.keys ([#1395](https://github.com/midwayjs/midway/issues/1395)) ([c44afc6](https://github.com/midwayjs/midway/commit/c44afc6cc6764a959d1fa7ae04d60099282d156a))
+* middleware with ctx.body ([#1389](https://github.com/midwayjs/midway/issues/1389)) ([77af5c0](https://github.com/midwayjs/midway/commit/77af5c0b456f1843f4dcfd3dbfd2c0aa244c51bd))
+
+
+
+
+
+# [3.0.0-beta.6](https://github.com/midwayjs/midway/compare/v3.0.0-beta.5...v3.0.0-beta.6) (2021-11-26)
+
+
+### Bug Fixes
+
+* class transformer method missing ([#1387](https://github.com/midwayjs/midway/issues/1387)) ([074e839](https://github.com/midwayjs/midway/commit/074e8393598dc95e2742f735df75a2191c5fe25d))
+
+
+
+
+
+# [3.0.0-beta.5](https://github.com/midwayjs/midway/compare/v3.0.0-beta.4...v3.0.0-beta.5) (2021-11-25)
+
+
+### Bug Fixes
+
+* [@match](https://github.com/match) empty args ([#1384](https://github.com/midwayjs/midway/issues/1384)) ([6f90fc9](https://github.com/midwayjs/midway/commit/6f90fc993ff01e078288ff664833c61c02dede51))
+* router sort ([#1383](https://github.com/midwayjs/midway/issues/1383)) ([f253887](https://github.com/midwayjs/midway/commit/f2538876d3eaf7dec55173d86b5b9caeeeb7be64))
+
+
+
+
+
+# [3.0.0-beta.4](https://github.com/midwayjs/midway/compare/v3.0.0-beta.3...v3.0.0-beta.4) (2021-11-24)
+
+
+### Bug Fixes
+
+* logger close before bootstrap close ([#1370](https://github.com/midwayjs/midway/issues/1370)) ([6cc2720](https://github.com/midwayjs/midway/commit/6cc2720ed3445e8ffccc96d124b80ed7e2517f08))
+
+
+### Features
+
+* add i18n ([#1375](https://github.com/midwayjs/midway/issues/1375)) ([bffefe0](https://github.com/midwayjs/midway/commit/bffefe07afe45777d49b5a76b9ab17fc2b9d9a55))
+* auto transform args to type ([#1372](https://github.com/midwayjs/midway/issues/1372)) ([bb3f7d2](https://github.com/midwayjs/midway/commit/bb3f7d2028a034e1926d9df554849332354c3762))
+* support global prefix url ([#1371](https://github.com/midwayjs/midway/issues/1371)) ([cc5fe44](https://github.com/midwayjs/midway/commit/cc5fe44e1d221590562dc71e1f33ae96093e0da7))
+
+
+
+
+
+# [3.0.0-beta.3](https://github.com/midwayjs/midway/compare/v3.0.0-beta.2...v3.0.0-beta.3) (2021-11-18)
+
+
+### Features
+
+* add component and framework config definition ([#1367](https://github.com/midwayjs/midway/issues/1367)) ([b2fe615](https://github.com/midwayjs/midway/commit/b2fe6157f99659471ff1333eca0b86bb889f61a3))
+
+
+
+
+
+# [3.0.0-beta.2](https://github.com/midwayjs/midway/compare/v3.0.0-beta.1...v3.0.0-beta.2) (2021-11-16)
+
+**Note:** Version bump only for package @midwayjs/core
+
+
+
+
+
 # [3.0.0-beta.1](https://github.com/midwayjs/midway/compare/v2.12.4...v3.0.0-beta.1) (2021-11-14)
 
 

package/README.md

@@ -5,7 +5,7 @@
 
 this is a sub package for midway.
 
-Document: [https://midwayjs.org/midway](https://midwayjs.org/midway)
+Document: [https://midwayjs.org](https://midwayjs.org)
 
 ## License
 

package/dist/baseFramework.d.ts

@@ -1,14 +1,14 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonExceptionFilterUnion, CommonMiddleware, MiddlewareRespond } from './interface';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, CommonMiddleware, MiddlewareRespond } from './interface';
 import { FrameworkType } from '@midwayjs/decorator';
 import { ILogger, LoggerOptions } from '@midwayjs/logger';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
 import { MidwayInformationService } from './service/informationService';
 import { MidwayLoggerService } from './service/loggerService';
-import { ContextMiddlewareManager } from './util/middlewareManager';
+import { ContextMiddlewareManager } from './common/middlewareManager';
 import { MidwayMiddlewareService } from './service/middlewareService';
-import { ExceptionFilterManager } from './util/exceptionFilterManager';
-export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions> implements IMidwayFramework<APP, OPT> {
+import { FilterManager } from './common/filterManager';
+export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>, CTX extends IMidwayContext, OPT extends IConfigurationOptions, ResOrNext = unknown, Next = unknown> implements IMidwayFramework<APP, CTX, OPT, ResOrNext, Next> {
     readonly applicationContext: IMidwayContainer;
     app: APP;
     configurationOptions: OPT;
@@ -17,14 +17,14 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
     protected defaultContext: {};
     protected BaseContextLoggerClass: any;
     protected ContextLoggerApplyLogger: string;
-    protected middlewareManager: ContextMiddlewareManager<CTX, any, any>;
-    protected exceptionFilterManager: ExceptionFilterManager<CTX, any, any>;
+    protected middlewareManager: ContextMiddlewareManager<CTX, ResOrNext, Next>;
+    protected filterManager: FilterManager<CTX, ResOrNext, Next>;
     protected composeMiddleware: any;
     loggerService: MidwayLoggerService;
     environmentService: MidwayEnvironmentService;
     configService: MidwayConfigService;
     informationService: MidwayInformationService;
-    middlewareService: MidwayMiddlewareService<CTX>;
+    middlewareService: MidwayMiddlewareService<CTX, ResOrNext, Next>;
     constructor(applicationContext: IMidwayContainer);
     init(): Promise<this>;
     abstract configure(options?: OPT): any;
@@ -72,14 +72,17 @@ 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;
     getProjectName(): string;
     getFrameworkName(): string;
     getDefaultContextLoggerClass(): any;
-    useMiddleware(Middleware: CommonMiddlewareUnion<CTX>): void;
-    useFilter(Filter: CommonExceptionFilterUnion<CTX>): void;
+    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>;
 }
 //# sourceMappingURL=baseFramework.d.ts.map

package/dist/baseFramework.js

@@ -18,15 +18,17 @@ const environmentService_1 = require("./service/environmentService");
 const configService_1 = require("./service/configService");
 const informationService_1 = require("./service/informationService");
 const loggerService_1 = require("./service/loggerService");
-const middlewareManager_1 = require("./util/middlewareManager");
+const middlewareManager_1 = require("./common/middlewareManager");
 const middlewareService_1 = require("./service/middlewareService");
-const exceptionFilterManager_1 = require("./util/exceptionFilterManager");
+const filterManager_1 = require("./common/filterManager");
+const util = require("util");
+const debug = util.debuglog('midway:debug');
 class BaseFramework {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
         this.defaultContext = {};
-        this.middlewareManager = new middlewareManager_1.ContextMiddlewareManager();
-        this.exceptionFilterManager = new exceptionFilterManager_1.ExceptionFilterManager();
+        this.middlewareManager = this.createMiddlewareManager();
+        this.filterManager = this.createFilterManager();
         this.composeMiddleware = null;
     }
     async init() {
@@ -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.exceptionFilterManager.useFilter(Filter);
+                return this.useFilter(Filter);
             },
         };
         for (const method of whiteList) {
@@ -204,30 +206,28 @@ class BaseFramework {
      * @deprecated
      */
     async afterContainerReady(options) { }
-    async getMiddleware(lastMiddleware) {
+    async applyMiddleware(lastMiddleware) {
         if (!this.composeMiddleware) {
-            this.middlewareManager.insertFirst(async (ctx, next) => {
+            this.middlewareManager.insertFirst((async (ctx, next) => {
                 let returnResult = undefined;
                 try {
                     const result = await next();
-                    returnResult = {
-                        result,
-                        error: undefined,
-                    };
+                    returnResult = await this.filterManager.runResultFilter(result, ctx);
                 }
                 catch (err) {
-                    returnResult = await this.exceptionFilterManager.run(err, ctx);
+                    returnResult = await this.filterManager.runErrorFilter(err, ctx);
+                }
+                if (returnResult.error) {
+                    throw returnResult.error;
                 }
-                return returnResult;
-            });
-            this.composeMiddleware = await this.middlewareService.compose(this.middlewareManager);
-            await this.exceptionFilterManager.init(this.applicationContext);
+                return returnResult.result;
+            }));
+            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,17 @@ class BaseFramework {
     useMiddleware(Middleware) {
         this.middlewareManager.insertLast(Middleware);
     }
+    getMiddleware() {
+        return this.middlewareManager;
+    }
     useFilter(Filter) {
-        this.exceptionFilterManager.useFilter(Filter);
+        return this.filterManager.useFilter(Filter);
+    }
+    createMiddlewareManager() {
+        return new middlewareManager_1.ContextMiddlewareManager();
+    }
+    createFilterManager() {
+        return new filterManager_1.FilterManager();
     }
 }
 __decorate([

package/dist/common/applicationManager.d.ts

@@ -0,0 +1,12 @@
+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[];
+    getWebLikeApplication(): IMidwayApplication[];
+}
+//# sourceMappingURL=applicationManager.d.ts.map

package/dist/common/applicationManager.js

@@ -0,0 +1,66 @@
+"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) {
+        return namespaces
+            .map(namespace => {
+            return this.getApplication(namespace);
+        })
+            .filter(app => {
+            return !!app;
+        });
+    }
+    getWebLikeApplication() {
+        return this.getApplications(['express', 'koa', 'egg', 'faas']);
+    }
+};
+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/filterManager.d.ts

@@ -0,0 +1,19 @@
+import { CommonFilterUnion, IMidwayContainer, IMidwayContext } from '../interface';
+export declare class FilterManager<CTX extends IMidwayContext = IMidwayContext, R = any, N = any> {
+    private errFilterList;
+    private successFilterList;
+    private exceptionMap;
+    private defaultErrFilter;
+    private matchFnList;
+    useFilter(Filters: CommonFilterUnion<CTX, R, N>): void;
+    init(applicationContext: IMidwayContainer): Promise<void>;
+    runErrorFilter(err: Error, ctx: CTX, res?: R, next?: N): Promise<{
+        result: any;
+        error: any;
+    }>;
+    runResultFilter(result: any, ctx: CTX, res?: R, next?: N): Promise<{
+        result: any;
+        error: any;
+    }>;
+}
+//# sourceMappingURL=filterManager.d.ts.map

package/dist/common/filterManager.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const util_1 = require("../util");
+class FilterManager {
+    constructor() {
+        this.errFilterList = [];
+        this.successFilterList = [];
+        this.exceptionMap = new WeakMap();
+        this.defaultErrFilter = undefined;
+        this.matchFnList = [];
+    }
+    useFilter(Filters) {
+        if (!Array.isArray(Filters)) {
+            Filters = [Filters];
+        }
+        for (const Filter of Filters) {
+            if ((0, decorator_1.getClassMetadata)(decorator_1.CATCH_KEY, Filter)) {
+                this.errFilterList.push(Filter);
+            }
+            if ((0, decorator_1.getClassMetadata)(decorator_1.MATCH_KEY, Filter)) {
+                this.successFilterList.push(Filter);
+            }
+        }
+    }
+    async init(applicationContext) {
+        // for catch exception
+        for (const FilterClass of this.errFilterList) {
+            const filter = await applicationContext.getAsync(FilterClass);
+            const exceptionMetadata = (0, decorator_1.getClassMetadata)(decorator_1.CATCH_KEY, FilterClass);
+            if (exceptionMetadata && exceptionMetadata.catchTargets) {
+                for (const Exception of exceptionMetadata.catchTargets) {
+                    this.exceptionMap.set(Exception, filter);
+                }
+            }
+            else {
+                // default filter
+                this.defaultErrFilter = filter;
+            }
+        }
+        // for success return
+        for (const FilterClass of this.successFilterList) {
+            const filter = await applicationContext.getAsync(FilterClass);
+            const matchMetadata = (0, decorator_1.getClassMetadata)(decorator_1.MATCH_KEY, FilterClass);
+            if (matchMetadata && matchMetadata.matchPattern) {
+                this.matchFnList.push({
+                    matchFn: (0, util_1.toPathMatch)(matchMetadata.matchPattern),
+                    target: filter,
+                });
+            }
+        }
+    }
+    async runErrorFilter(err, ctx, res, next) {
+        let result, error;
+        if (this.exceptionMap.has(err.constructor)) {
+            const filter = this.exceptionMap.get(err.constructor);
+            result = await filter.catch(err, ctx, res, next);
+        }
+        else if (this.defaultErrFilter) {
+            result = await this.defaultErrFilter.catch(err, ctx, res, next);
+        }
+        else {
+            error = err;
+        }
+        return {
+            result,
+            error,
+        };
+    }
+    async runResultFilter(result, ctx, res, next) {
+        let returnValue = result;
+        for (const matchData of this.matchFnList) {
+            if (matchData.matchFn(ctx, res)) {
+                returnValue = await matchData.target.match(returnValue, ctx, res, next);
+            }
+        }
+        return {
+            result: returnValue,
+            error: undefined,
+        };
+    }
+}
+exports.FilterManager = FilterManager;
+//# sourceMappingURL=filterManager.js.map

package/dist/common/middlewareManager.d.ts

@@ -0,0 +1,68 @@
+import { CommonMiddleware, CommonMiddlewareUnion, IMidwayContext } from '../interface';
+export declare class ContextMiddlewareManager<CTX extends IMidwayContext, R, N> extends Array<CommonMiddleware<CTX, R, N>> {
+    /**
+     * insert a middleware or middleware array to first
+     * @param middleware
+     */
+    insertFirst(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
+    /**
+     * insert a middleware or middleware array to last
+     * @param middleware
+     */
+    insertLast(middleware: CommonMiddlewareUnion<CTX, R, N>): void;
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrBeforeMiddleware
+     */
+    insertBefore(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrBeforeMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * insert a middleware or middleware array to after another middleware
+     * @param middleware
+     * @param idxOrAfterMiddleware
+     */
+    insertAfter(middleware: CommonMiddlewareUnion<CTX, R, N>, idxOrAfterMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * move a middleware after another middleware
+     * @param middlewareOrName
+     * @param afterMiddleware
+     */
+    findAndInsertAfter(middlewareOrName: CommonMiddleware<CTX, R, N> | string, afterMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * move a middleware before another middleware
+     * @param middlewareOrName
+     * @param beforeMiddleware
+     */
+    findAndInsertBefore(middlewareOrName: CommonMiddleware<CTX, R, N> | string, beforeMiddleware: CommonMiddleware<CTX, R, N> | string | number): void;
+    /**
+     * find middleware and move to first
+     * @param middlewareOrName
+     */
+    findAndInsertFirst(middlewareOrName: CommonMiddleware<CTX, R, N> | string): void;
+    /**
+     * find middleware and move to last
+     * @param middlewareOrName
+     */
+    findAndInsertLast(middlewareOrName: CommonMiddleware<CTX, R, N> | string): void;
+    /**
+     * find a middleware and return index
+     * @param middlewareOrName
+     */
+    findItemIndex(middlewareOrName: CommonMiddleware<CTX, R, N> | string | number): number;
+    findItem(middlewareOrName: CommonMiddleware<CTX, R, N> | string | number): CommonMiddleware<CTX, R, N>;
+    /**
+     * get name from middleware
+     * @param middleware
+     */
+    getMiddlewareName(middleware: CommonMiddleware<CTX, R, N>): string;
+    /**
+     * remove a middleware
+     * @param middlewareOrNameOrIdx
+     */
+    remove(middlewareOrNameOrIdx: CommonMiddleware<CTX, R, N> | string | number): CommonMiddleware<CTX, R, N>;
+    /**
+     * get middleware name list
+     */
+    getNames(): string[];
+}
+//# sourceMappingURL=middlewareManager.d.ts.map