@midwayjs/core 3.4.6 → 3.4.10

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

@@ -9,7 +9,7 @@ const error_1 = require("../error");
 const glob_1 = require("@midwayjs/glob");
 const path_1 = require("path");
 const decorator_1 = require("@midwayjs/decorator");
-const DEFAULT_PATTERN = ['**/**.ts', '**/**.js'];
+const interface_1 = require("../interface");
 class DataSourceManager {
     constructor() {
         this.dataSource = new Map();
@@ -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
@@ -104,8 +107,9 @@ function globModels(globString, appDir) {
     const cwd = (0, path_1.join)(appDir, globString);
     const models = [];
     // string will be glob file
-    const files = (0, glob_1.run)(DEFAULT_PATTERN, {
+    const files = (0, glob_1.run)(interface_1.DEFAULT_PATTERN, {
         cwd,
+        ignore: interface_1.IGNORE_PATTERN,
     });
     for (const file of files) {
         const exports = require(file);

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

@@ -4,6 +4,7 @@ exports.CustomModuleDetector = exports.DirectoryFileDetector = exports.AbstractF
 const decorator_1 = require("@midwayjs/decorator");
 const glob_1 = require("@midwayjs/glob");
 const error_1 = require("../error");
+const interface_1 = require("../interface");
 class AbstractFileDetector {
     constructor(options) {
         this.options = options;
@@ -14,9 +15,8 @@ class AbstractFileDetector {
     }
 }
 exports.AbstractFileDetector = AbstractFileDetector;
-const DEFAULT_PATTERN = ['**/**.ts', '**/**.tsx', '**/**.js'];
+const DEFAULT_GLOB_PATTERN = ['**/**.tsx'].concat(interface_1.DEFAULT_PATTERN);
 const DEFAULT_IGNORE_PATTERN = [
-    '**/**.d.ts',
     '**/logs/**',
     '**/run/**',
     '**/public/**',
@@ -27,11 +27,10 @@ const DEFAULT_IGNORE_PATTERN = [
     '**/**.test.ts',
     '**/**.test.js',
     '**/__test__/**',
-];
+].concat(interface_1.IGNORE_PATTERN);
 class DirectoryFileDetector extends AbstractFileDetector {
     constructor() {
         super(...arguments);
-        this.directoryFilterArray = [];
         this.duplicateModuleCheckSet = new Map();
     }
     run(container) {
@@ -39,13 +38,15 @@ class DirectoryFileDetector extends AbstractFileDetector {
             .concat(this.options.loadDir || [])
             .concat(this.extraDetectorOptions.loadDir || []);
         for (const dir of loadDirs) {
-            const fileResults = (0, glob_1.run)(DEFAULT_PATTERN.concat(this.options.pattern || []).concat(this.extraDetectorOptions.pattern || []), {
+            const fileResults = (0, glob_1.run)(DEFAULT_GLOB_PATTERN.concat(this.options.pattern || []).concat(this.extraDetectorOptions.pattern || []), {
                 cwd: dir,
                 ignore: DEFAULT_IGNORE_PATTERN.concat(this.options.ignore || []).concat(this.extraDetectorOptions.ignore || []),
             });
             // 检查重复模块
             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/common/middlewareManager.d.ts

@@ -60,6 +60,8 @@ export declare class ContextMiddlewareManager<CTX extends IMidwayContext, R, N>
      * @param middlewareOrNameOrIdx
      */
     remove(middlewareOrNameOrIdx: CommonMiddleware<CTX, R, N> | string | number): CommonMiddleware<CTX, R, N>;
+    push(...items: any[]): number;
+    unshift(...items: any[]): number;
     /**
      * get middleware name list
      */

package/dist/common/middlewareManager.js

@@ -170,6 +170,22 @@ class ContextMiddlewareManager extends Array {
             }
         }
     }
+    push(...items) {
+        items.forEach(item => {
+            if (typeof item !== 'string' && !this.getMiddlewareName(item)) {
+                item._name = 'anonymous';
+            }
+        });
+        return super.push(...items);
+    }
+    unshift(...items) {
+        items.forEach(item => {
+            if (typeof item !== 'string' && !this.getMiddlewareName(item)) {
+                item._name = 'anonymous';
+            }
+        });
+        return super.unshift(...items);
+    }
     /**
      * get middleware name list
      */

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

@@ -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";
@@ -483,5 +483,7 @@ export interface MidwayConfig extends FileConfigOption<typeof _default> {
 }
 export declare const ASYNC_CONTEXT_KEY: unique symbol;
 export declare const ASYNC_CONTEXT_MANAGER_KEY = "MIDWAY_ASYNC_CONTEXT_MANAGER_KEY";
+export declare const DEFAULT_PATTERN: string[];
+export declare const IGNORE_PATTERN: string[];
 export {};
 //# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASYNC_CONTEXT_MANAGER_KEY = exports.ASYNC_CONTEXT_KEY = exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.MidwayProcessTypeEnum = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.ObjectLifeCycleEvent = void 0;
+exports.IGNORE_PATTERN = exports.DEFAULT_PATTERN = exports.ASYNC_CONTEXT_MANAGER_KEY = exports.ASYNC_CONTEXT_KEY = exports.MIDWAY_LOGGER_WRITEABLE_DIR = exports.MidwayProcessTypeEnum = exports.REQUEST_CTX_LOGGER_CACHE_KEY = exports.HTTP_SERVER_KEY = exports.REQUEST_OBJ_CTX_KEY = exports.REQUEST_CTX_KEY = exports.ObjectLifeCycleEvent = void 0;
 var ObjectLifeCycleEvent;
 (function (ObjectLifeCycleEvent) {
     ObjectLifeCycleEvent["BEFORE_BIND"] = "beforeBind";
@@ -21,4 +21,13 @@ var MidwayProcessTypeEnum;
 exports.MIDWAY_LOGGER_WRITEABLE_DIR = 'MIDWAY_LOGGER_WRITEABLE_DIR';
 exports.ASYNC_CONTEXT_KEY = Symbol('ASYNC_CONTEXT_KEY');
 exports.ASYNC_CONTEXT_MANAGER_KEY = 'MIDWAY_ASYNC_CONTEXT_MANAGER_KEY';
+exports.DEFAULT_PATTERN = [
+    '**/**.ts',
+    '**/**.js',
+    '**/**.mts',
+    '**/**.mjs',
+    '**/**.cts',
+    '**/**.cjs'
+];
+exports.IGNORE_PATTERN = ['**/**.d.ts', '**/**.d.mts', '**/**.d.cts'];
 //# sourceMappingURL=interface.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.4.6",
+  "version": "3.4.10",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -45,5 +45,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "36687482782bcf526efc2a4773c09e166820c1a8"
+  "gitHead": "aeb117633ecbc3299002b220f436dc3b5450d361"
 }