@midwayjs/core 3.4.7 → 3.4.11

package/dist/baseFramework.d.ts

@@ -1,4 +1,4 @@
-import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, CommonMiddleware, MiddlewareRespond } from './interface';
+import { CommonMiddlewareUnion, IConfigurationOptions, IMidwayApplication, IMidwayBootstrapOptions, IMidwayContainer, IMidwayContext, IMidwayFramework, CommonFilterUnion, MiddlewareRespond } from './interface';
 import { ILogger, LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import { MidwayEnvironmentService } from './service/environmentService';
 import { MidwayConfigService } from './service/configService';
@@ -74,7 +74,7 @@ export declare abstract class BaseFramework<APP extends IMidwayApplication<CTX>,
      * @deprecated
      */
     protected afterContainerReady(options: Partial<IMidwayBootstrapOptions>): Promise<void>;
-    applyMiddleware<R, N>(lastMiddleware?: CommonMiddleware<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
+    applyMiddleware<R, N>(lastMiddleware?: CommonMiddlewareUnion<CTX, R, N>): Promise<MiddlewareRespond<CTX, R, N>>;
     getLogger(name?: string): ILogger;
     getCoreLogger(): ILogger;
     createLogger(name: string, option?: LoggerOptions): ILogger;

package/dist/baseFramework.js

@@ -234,18 +234,19 @@ class BaseFramework {
     async afterContainerReady(options) { }
     async applyMiddleware(lastMiddleware) {
         var _a;
-        if (!this.applicationContext.hasObject(interface_1.ASYNC_CONTEXT_MANAGER_KEY)) {
-            const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
-                false;
-            const contextManager = asyncContextManagerEnabled
-                ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.asyncContextManager) || new asyncContextManager_1.NoopContextManager()
-                : new asyncContextManager_1.NoopContextManager();
-            if (asyncContextManagerEnabled) {
-                contextManager.enable();
-            }
-            this.applicationContext.registerObject(interface_1.ASYNC_CONTEXT_MANAGER_KEY, contextManager);
-        }
         if (!this.composeMiddleware) {
+            if (!this.applicationContext.hasObject(interface_1.ASYNC_CONTEXT_MANAGER_KEY)) {
+                const asyncContextManagerEnabled = this.configService.getConfiguration('asyncContextManager.enable') ||
+                    false;
+                const contextManager = asyncContextManagerEnabled
+                    ? ((_a = this.bootstrapOptions) === null || _a === void 0 ? void 0 : _a.asyncContextManager) ||
+                        new asyncContextManager_1.NoopContextManager()
+                    : new asyncContextManager_1.NoopContextManager();
+                if (asyncContextManagerEnabled) {
+                    contextManager.enable();
+                }
+                this.applicationContext.registerObject(interface_1.ASYNC_CONTEXT_MANAGER_KEY, contextManager);
+            }
             this.middlewareManager.insertFirst((async (ctx, next) => {
                 // warp with context manager
                 const rootContext = asyncContextManager_1.ASYNC_ROOT_CONTEXT.setValue(interface_1.ASYNC_CONTEXT_KEY, ctx);
@@ -271,11 +272,12 @@ class BaseFramework {
             await this.filterManager.init(this.applicationContext);
         }
         if (lastMiddleware) {
-            return await this.middlewareService.compose([this.composeMiddleware, lastMiddleware], this.app);
-        }
-        else {
-            return this.composeMiddleware;
+            lastMiddleware = Array.isArray(lastMiddleware)
+                ? lastMiddleware
+                : [lastMiddleware];
+            return await this.middlewareService.compose([this.composeMiddleware, ...lastMiddleware], this.app);
         }
+        return this.composeMiddleware;
     }
     getLogger(name) {
         var _a;

package/dist/common/dataSourceManager.d.ts

@@ -19,7 +19,7 @@ export declare abstract class DataSourceManager<T> {
      * @param dataSourceName
      */
     isConnected(dataSourceName: string): Promise<boolean>;
-    createInstance(config: any, clientName: any): Promise<T | void>;
+    createInstance(config: any, clientName: any, options?: CreateInstanceOptions): Promise<T | void>;
     /**
      * get data source name by model or repository
      * @param modelOrRepository
@@ -32,4 +32,7 @@ export declare abstract class DataSourceManager<T> {
     stop(): Promise<void>;
 }
 export declare function globModels(globString: string, appDir: string): any[];
+export interface CreateInstanceOptions {
+    cacheInstance?: boolean | undefined;
+}
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -18,35 +18,36 @@ class DataSourceManager {
     }
     async initDataSource(options, appDir) {
         this.options = options;
-        if (options.dataSource) {
-            for (const dataSourceName in options.dataSource) {
-                const dataSourceOptions = options.dataSource[dataSourceName];
-                if (dataSourceOptions['entities']) {
-                    const entities = new Set();
-                    // loop entities and glob files to model
-                    for (const entity of dataSourceOptions['entities']) {
-                        if (typeof entity === 'string') {
-                            // string will be glob file
-                            const models = globModels(entity, appDir);
-                            for (const model of models) {
-                                entities.add(model);
-                                this.modelMapping.set(model, dataSourceName);
-                            }
-                        }
-                        else {
-                            // model will be add to array
-                            entities.add(entity);
-                            this.modelMapping.set(entity, dataSourceName);
+        if (!options.dataSource) {
+            throw new error_1.MidwayParameterError('DataSourceManager must set options.dataSource.');
+        }
+        for (const dataSourceName in options.dataSource) {
+            const dataSourceOptions = options.dataSource[dataSourceName];
+            if (dataSourceOptions['entities']) {
+                const entities = new Set();
+                // loop entities and glob files to model
+                for (const entity of dataSourceOptions['entities']) {
+                    if (typeof entity === 'string') {
+                        // string will be glob file
+                        const models = globModels(entity, appDir);
+                        for (const model of models) {
+                            entities.add(model);
+                            this.modelMapping.set(model, dataSourceName);
                         }
                     }
-                    dataSourceOptions['entities'] = Array.from(entities);
+                    else {
+                        // model will be add to array
+                        entities.add(entity);
+                        this.modelMapping.set(entity, dataSourceName);
+                    }
                 }
-                // create data source
-                await this.createInstance(dataSourceOptions, dataSourceName);
+                dataSourceOptions['entities'] = Array.from(entities);
             }
-        }
-        else {
-            throw new error_1.MidwayParameterError('DataSourceManager must set options.dataSource.');
+            // create data source
+            const opts = {
+                cacheInstance: options.cacheInstance, // will default true
+            };
+            await this.createInstance(dataSourceOptions, dataSourceName, opts);
         }
     }
     /**
@@ -71,18 +72,20 @@ class DataSourceManager {
      * @param dataSourceName
      */
     async isConnected(dataSourceName) {
-        return this.checkConnected(this.getDataSource(dataSourceName));
+        const inst = this.getDataSource(dataSourceName);
+        return inst ? this.checkConnected(inst) : false;
     }
-    async createInstance(config, clientName) {
+    async createInstance(config, clientName, options) {
+        const cache = options && typeof options.cacheInstance === 'boolean'
+            ? options.cacheInstance
+            : true;
         // options.default will be merge in to options.clients[id]
-        config = (0, extend_1.extend)(true, {}, this.options['default'], config);
-        const client = await this.createDataSource(config, clientName);
-        if (client) {
-            if (clientName) {
-                this.dataSource.set(clientName, client);
-            }
-            return client;
+        const configNow = (0, extend_1.extend)(true, {}, this.options['default'], config);
+        const client = await this.createDataSource(configNow, clientName);
+        if (cache && clientName && client) {
+            this.dataSource.set(clientName, client);
         }
+        return client;
     }
     /**
      * get data source name by model or repository

package/dist/common/fileDetector.d.ts

@@ -7,19 +7,18 @@ export declare abstract class AbstractFileDetector<T> implements IFileDetector {
     setExtraDetectorOptions(detectorOptions: T): void;
 }
 export declare class DirectoryFileDetector extends AbstractFileDetector<{
-    loadDir: string | string[];
-    pattern: string | string[];
-    ignore: string | string[];
-    namespace: string;
-    conflictCheck: boolean;
+    loadDir?: string | string[];
+    pattern?: string | string[];
+    ignore?: string | string[];
+    namespace?: string;
+    conflictCheck?: boolean;
 }> {
-    private directoryFilterArray;
     private duplicateModuleCheckSet;
     run(container: any): void;
 }
 export declare class CustomModuleDetector extends AbstractFileDetector<{
-    modules: any[];
-    namespace: string;
+    modules?: any[];
+    namespace?: string;
 }> {
     run(container: any): void;
 }

package/dist/common/fileDetector.js

@@ -31,7 +31,6 @@ const DEFAULT_IGNORE_PATTERN = [
 class DirectoryFileDetector extends AbstractFileDetector {
     constructor() {
         super(...arguments);
-        this.directoryFilterArray = [];
         this.duplicateModuleCheckSet = new Map();
     }
     run(container) {
@@ -45,7 +44,9 @@ class DirectoryFileDetector extends AbstractFileDetector {
             });
             // 检查重复模块
             const checkDuplicatedHandler = (module, options) => {
-                if (this.extraDetectorOptions.conflictCheck && decorator_1.Types.isClass(module)) {
+                if ((this.options.conflictCheck ||
+                    this.extraDetectorOptions.conflictCheck) &&
+                    decorator_1.Types.isClass(module)) {
                     const name = (0, decorator_1.getProviderName)(module);
                     if (name) {
                         if (this.duplicateModuleCheckSet.has(name)) {
@@ -58,46 +59,14 @@ class DirectoryFileDetector extends AbstractFileDetector {
                 }
             };
             for (const file of fileResults) {
-                if (this.directoryFilterArray.length) {
-                    for (const resolveFilter of this.directoryFilterArray) {
-                        if (typeof resolveFilter.pattern === 'string') {
-                            if (file.includes(resolveFilter.pattern)) {
-                                const exports = resolveFilter.ignoreRequire
-                                    ? undefined
-                                    : require(file);
-                                resolveFilter.filter(exports, file, this);
-                                continue;
-                            }
-                        }
-                        else if (decorator_1.Types.isRegExp(resolveFilter.pattern)) {
-                            if (resolveFilter.pattern.test(file)) {
-                                const exports = resolveFilter.ignoreRequire
-                                    ? undefined
-                                    : require(file);
-                                resolveFilter.filter(exports, file, this);
-                                continue;
-                            }
-                        }
-                        const exports = require(file);
-                        // add module to set
-                        container.bindClass(exports, {
-                            namespace: this.options.namespace,
-                            srcPath: file,
-                            createFrom: 'file',
-                            bindHook: checkDuplicatedHandler,
-                        });
-                    }
-                }
-                else {
-                    const exports = require(file);
-                    // add module to set
-                    container.bindClass(exports, {
-                        namespace: this.options.namespace,
-                        srcPath: file,
-                        createFrom: 'file',
-                        bindHook: checkDuplicatedHandler,
-                    });
-                }
+                const exports = require(file);
+                // add module to set
+                container.bindClass(exports, {
+                    namespace: this.options.namespace,
+                    srcPath: file,
+                    createFrom: 'file',
+                    bindHook: checkDuplicatedHandler,
+                });
             }
         }
         // check end

package/dist/error/base.js

@@ -46,6 +46,9 @@ class MidwayHttpError extends MidwayError {
                 ? resOrMessage
                 : resOrMessage.message
             : http_1.STATUS_CODES[status], code !== null && code !== void 0 ? code : String(status), options);
+        if (resOrMessage && resOrMessage['stack']) {
+            this.stack = resOrMessage['stack'];
+        }
         this.status = status;
     }
 }

package/dist/interface.d.ts

@@ -307,9 +307,9 @@ export declare type NextFunction = () => Promise<any>;
  * Common middleware definition
  */
 export interface IMiddleware<CTX, R, N = unknown> {
-    resolve: (app?: IMidwayApplication) => FunctionMiddleware<CTX, R, N> | Promise<FunctionMiddleware<CTX, R, N>>;
-    match?: (ctx?: CTX) => boolean;
-    ignore?: (ctx?: CTX) => boolean;
+    resolve: (app: IMidwayApplication) => FunctionMiddleware<CTX, R, N> | Promise<FunctionMiddleware<CTX, R, N>>;
+    match?: (ctx: CTX) => boolean;
+    ignore?: (ctx: CTX) => boolean;
 }
 export declare type FunctionMiddleware<CTX, R, N = unknown> = N extends true ? (req: CTX, res: R, next: N) => any : (context: CTX, next: R, options?: any) => any;
 export declare type ClassMiddleware<CTX, R, N> = new (...args: any[]) => IMiddleware<CTX, R, N>;
@@ -462,7 +462,7 @@ export interface IMidwayFramework<APP extends IMidwayApplication<CTX>, CTX exten
     getProjectName(): string;
     useMiddleware(Middleware: CommonMiddlewareUnion<CTX, ResOrNext, Next>): void;
     getMiddleware(): ContextMiddlewareManager<CTX, ResOrNext, Next>;
-    applyMiddleware(lastMiddleware?: CommonMiddleware<CTX, ResOrNext, Next>): Promise<MiddlewareRespond<CTX, ResOrNext, Next>>;
+    applyMiddleware(lastMiddleware?: CommonMiddlewareUnion<CTX, ResOrNext, Next>): Promise<MiddlewareRespond<CTX, ResOrNext, Next>>;
     useFilter(Filter: CommonFilterUnion<CTX, ResOrNext, Next>): any;
 }
 export declare const MIDWAY_LOGGER_WRITEABLE_DIR = "MIDWAY_LOGGER_WRITEABLE_DIR";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.4.7",
+  "version": "3.4.11",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -21,7 +21,7 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.4.4",
+    "@midwayjs/decorator": "^3.4.11",
     "koa": "2.13.4",
     "midway-test-component": "*",
     "mm": "3.2.0",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "3c60619a65c6776d99fbf0b30ac454d3cb6926b9"
+  "gitHead": "942dd076d60f27d6004640fa6dd9a9724efc559d"
 }