@midwayjs/core 3.11.0 → 3.11.4

package/dist/common/dataSourceManager.d.ts

@@ -1,9 +1,34 @@
+export interface CreateDataSourceInstanceOptions {
+    /**
+     * @default false
+     */
+    validateConnection?: boolean;
+    /**
+     * @default true
+     */
+    cacheInstance?: boolean | undefined;
+}
+interface DataSourceConfig extends CreateDataSourceInstanceOptions {
+    dataSource: {
+        entities?: Array<string | unknown>;
+        [key: string]: unknown;
+    };
+}
 export declare abstract class DataSourceManager<T> {
     protected dataSource: Map<string, T>;
-    protected options: {};
+    protected options: Partial<DataSourceConfig>;
     protected modelMapping: WeakMap<object, any>;
     private innerDefaultDataSourceName;
-    protected initDataSource(options: any, appDir: string): Promise<void>;
+    protected initDataSource(dataSourceConfig: {
+        dataSource: {
+            entities?: Array<string | unknown>;
+            [key: string]: unknown;
+        };
+        cacheInstance?: boolean;
+        validateConnection?: boolean;
+    }, appDirOrOptions: {
+        appDir: string;
+    } | string): Promise<void>;
     /**
      * get a data source instance
      * @param dataSourceName
@@ -35,14 +60,5 @@ export declare abstract class DataSourceManager<T> {
 }
 export declare function formatGlobString(globString: string): string[];
 export declare function globModels(globString: string, appDir: string): any[];
-export interface CreateDataSourceInstanceOptions {
-    /**
-     * @default false
-     */
-    validateConnection?: boolean;
-    /**
-     * @default true
-     */
-    cacheInstance?: boolean | undefined;
-}
+export {};
 //# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/common/dataSourceManager.js

@@ -10,43 +10,51 @@ const glob_1 = require("@midwayjs/glob");
 const path_1 = require("path");
 const types_1 = require("../util/types");
 const constants_1 = require("../constants");
+const util_1 = require("util");
+const debug = (0, util_1.debuglog)('midway:debug');
 class DataSourceManager {
     constructor() {
         this.dataSource = new Map();
         this.options = {};
         this.modelMapping = new WeakMap();
     }
-    async initDataSource(options, appDir) {
-        this.options = options;
-        if (!options.dataSource) {
+    async initDataSource(dataSourceConfig, appDirOrOptions) {
+        this.options = dataSourceConfig;
+        if (!this.options.dataSource) {
             throw new error_1.MidwayParameterError('[DataSourceManager] must set options.dataSource.');
         }
-        for (const dataSourceName in options.dataSource) {
-            const dataSourceOptions = options.dataSource[dataSourceName];
+        if (typeof appDirOrOptions === 'string') {
+            appDirOrOptions = {
+                appDir: appDirOrOptions,
+            };
+        }
+        for (const dataSourceName in dataSourceConfig.dataSource) {
+            const dataSourceOptions = dataSourceConfig.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);
+                        const models = globModels(entity, appDirOrOptions.appDir);
                         for (const model of models) {
                             entities.add(model);
                             this.modelMapping.set(model, dataSourceName);
                         }
                     }
                     else {
-                        // model will be add to array
+                        // model will be added to array
                         entities.add(entity);
                         this.modelMapping.set(entity, dataSourceName);
                     }
                 }
                 dataSourceOptions['entities'] = Array.from(entities);
+                debug(`[core]: DataManager load ${dataSourceOptions['entities'].length} models from ${dataSourceName}.`);
             }
             // create data source
             const opts = {
-                cacheInstance: options.cacheInstance,
-                validateConnection: options.validateConnection,
+                cacheInstance: dataSourceConfig.cacheInstance,
+                validateConnection: dataSourceConfig.validateConnection,
             };
             await this.createInstance(dataSourceOptions, dataSourceName, opts);
         }

package/dist/decorator/decoratorManager.js

@@ -7,6 +7,7 @@ const constant_1 = require("./constant");
 const types_1 = require("../util/types");
 const camelCase_1 = require("../util/camelCase");
 const util_1 = require("../util");
+const pathFileUtil_1 = require("../util/pathFileUtil");
 const debug = require('util').debuglog('midway:core');
 exports.PRELOAD_MODULE_KEY = 'INJECTION_PRELOAD_MODULE_KEY';
 exports.INJECT_CLASS_KEY_PREFIX = 'INJECTION_CLASS_META_DATA';
@@ -249,6 +250,13 @@ let manager = new DecoratorManager();
 if (typeof global === 'object') {
     if (global['MIDWAY_GLOBAL_DECORATOR_MANAGER']) {
         console.warn('DecoratorManager not singleton and please check @midwayjs/core version by "npm ls @midwayjs/core"');
+        const coreModulePathList = (0, pathFileUtil_1.getModuleRequirePathList)('@midwayjs/core');
+        if (coreModulePathList.length) {
+            console.info('The module may be located in:');
+            coreModulePathList.forEach((path, index) => {
+                console.info(`${index + 1}. ${path}`);
+            });
+        }
         manager = global['MIDWAY_GLOBAL_DECORATOR_MANAGER'];
     }
     else {

package/dist/decorator/web/paramMapping.d.ts

@@ -1,4 +1,4 @@
-import { IMidwayContext, PipeUnionTransform } from '../../interface';
+import { IMidwayContext, ParamDecoratorOptions, PipeUnionTransform } from '../../interface';
 export declare enum RouteParamTypes {
     QUERY = "query",
     BODY = "body",
@@ -22,7 +22,7 @@ export interface RouterParamValue {
 export declare type KoaLikeCustomParamDecorator<T = unknown> = (ctx: IMidwayContext) => T | Promise<T>;
 export declare type ExpressLikeCustomParamDecorator<T = unknown> = (req: any, res: any) => T | Promise<T>;
 export declare type CustomParamDecorator<T = unknown> = KoaLikeCustomParamDecorator<T> | ExpressLikeCustomParamDecorator<T>;
-export declare const createRequestParamDecorator: (transform: CustomParamDecorator, pipes?: Array<PipeUnionTransform>) => ParameterDecorator;
+export declare const createRequestParamDecorator: (transform: CustomParamDecorator, pipesOrOptions?: ParamDecoratorOptions | Array<PipeUnionTransform>) => ParameterDecorator;
 export declare const Session: (propertyOrPipes?: string | PipeUnionTransform[], pipes?: PipeUnionTransform[]) => ParameterDecorator;
 export declare const Body: (propertyOrPipes?: string | PipeUnionTransform[], pipes?: PipeUnionTransform[]) => ParameterDecorator;
 export declare const Query: (propertyOrPipes?: string | PipeUnionTransform[], pipes?: PipeUnionTransform[]) => ParameterDecorator;

package/dist/decorator/web/paramMapping.js

@@ -33,8 +33,14 @@ const createParamMapping = function (type) {
         });
     };
 };
-const createRequestParamDecorator = function (transform, pipes) {
-    return createParamMapping(RouteParamTypes.CUSTOM)(transform, pipes);
+const createRequestParamDecorator = function (transform, pipesOrOptions) {
+    pipesOrOptions = pipesOrOptions || {};
+    if (Array.isArray(pipesOrOptions)) {
+        pipesOrOptions = {
+            pipes: pipesOrOptions,
+        };
+    }
+    return createParamMapping(RouteParamTypes.CUSTOM)(transform, pipesOrOptions.pipes);
 };
 exports.createRequestParamDecorator = createRequestParamDecorator;
 const Session = (propertyOrPipes, pipes) => createParamMapping(RouteParamTypes.SESSION)(propertyOrPipes, pipes);

package/dist/interface.d.ts

@@ -3,6 +3,43 @@ import type { LoggerOptions, LoggerContextFormat } from '@midwayjs/logger';
 import * as EventEmitter from 'events';
 import type { AsyncContextManager } from './common/asyncContextManager';
 import type { LoggerFactory } from './common/loggerFactory';
+export type PowerPartial<T> = {
+    [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
+};
+/**
+ * Make object property writeable
+ */
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/**
+ * Utility type that adds a `fn` parameter to each method in the input type `T`,
+ * transforming the original method's parameter types and return type into a function type.
+ *
+ * @example
+ * // Input:
+ * interface MyInterface {
+ *   method1(a: string, b: number): boolean;
+ *   method2(x: Foo, y: Bar): void;
+ * }
+ *
+ * // Output:
+ * interface MyInterfaceWithFn {
+ *   method1(fn: (a: string, b: number) => boolean): void;
+ *   method2(fn: (x: Foo, y: Bar) => void): void;
+ * }
+ */
+export type WithFn<T> = {
+    [K in keyof T]: T[K] extends (...args: infer P) => infer R ? (fn: (...args: P) => R) => void : T[K];
+};
+/**
+ * Transform an object type `T` with methods that have function-type parameters
+ * to a new object type with the same methods, but with the parameters
+ * extracted as separate properties.
+ */
+export type WithoutFn<T> = {
+    [K in keyof T]: T[K] extends (arg: any, ...args: any[]) => any ? (...args: Parameters<T[K]>) => ReturnType<T[K]> : T[K];
+};
 export type MiddlewareParamArray = Array<string | any>;
 export type ObjectIdentifier = string | Symbol;
 export type GroupModeType = 'one' | 'multi';
@@ -243,6 +280,7 @@ export interface JoinPoint {
     target: any;
     args: any[];
     proceed?(...args: any[]): any;
+    proceedIsAsyncFunction?: boolean;
 }
 export interface AspectMetadata {
     aspectTarget: any;
@@ -322,9 +360,6 @@ export interface MidwayCoreDefaultConfig {
         enable: boolean;
     };
 }
-export type PowerPartial<T> = {
-    [U in keyof T]?: T[U] extends {} ? PowerPartial<T[U]> : T[U];
-};
 export type ServiceFactoryConfigOption<OPTIONS> = {
     default?: PowerPartial<OPTIONS>;
     client?: PowerPartial<OPTIONS>;
@@ -347,12 +382,6 @@ type ConfigType<T> = T extends (...args: any[]) => any ? Writable<PowerPartial<R
  * Get definition from config
  */
 export type FileConfigOption<T, K = unknown> = K extends keyof ConfigType<T> ? Pick<ConfigType<T>, K> : ConfigType<T>;
-/**
- * Make object property writeable
- */
-export type Writable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
 /**
  * Lifecycle Definition
  * 生命周期定义
@@ -406,11 +435,11 @@ export interface ObjectBeforeDestroyOptions extends ObjectLifeCycleOptions {
  * 对象生命周期
  */
 export interface IObjectLifeCycle {
-    onBeforeBind(fn: (Clzz: any, options: ObjectBeforeBindOptions) => void): any;
-    onBeforeObjectCreated(fn: (Clzz: any, options: ObjectBeforeCreatedOptions) => void): any;
-    onObjectCreated<T>(fn: (ins: T, options: ObjectCreatedOptions<T>) => void): any;
-    onObjectInit<T>(fn: (ins: T, options: ObjectInitOptions) => void): any;
-    onBeforeObjectDestroy<T>(fn: (ins: T, options: ObjectBeforeDestroyOptions) => void): any;
+    onBeforeBind(Clzz: any, options: ObjectBeforeBindOptions): void;
+    onBeforeObjectCreated(Clzz: any, options: ObjectBeforeCreatedOptions): void;
+    onObjectCreated<T>(ins: T, options: ObjectCreatedOptions<T>): void;
+    onObjectInit<T>(ins: T, options: ObjectInitOptions): void;
+    onBeforeObjectDestroy<T>(ins: T, options: ObjectBeforeDestroyOptions): void;
 }
 /**
  * Object Definition
@@ -536,7 +565,7 @@ export interface IIdentifierRelationShip {
     hasRelation(id: ObjectIdentifier): boolean;
     getRelation(id: ObjectIdentifier): string;
 }
-export interface IMidwayContainer extends IObjectFactory, IObjectLifeCycle {
+export interface IMidwayContainer extends IObjectFactory, WithFn<IObjectLifeCycle> {
     parent: IMidwayContainer;
     identifierMapping: IIdentifierRelationShip;
     objectCreateEventTarget: EventEmitter;

package/dist/service/aspectService.js

@@ -78,6 +78,7 @@ let MidwayAspectService = class MidwayAspectService {
                     target: this,
                     args: args,
                     proceed: newProceed,
+                    proceedIsAsyncFunction: true,
                 };
                 if (typeof aspectObject === 'function') {
                     aspectObject = aspectObject();
@@ -122,6 +123,7 @@ let MidwayAspectService = class MidwayAspectService {
                     target: this,
                     args: args,
                     proceed: newProceed,
+                    proceedIsAsyncFunction: false,
                 };
                 if (typeof aspectObject === 'function') {
                     aspectObject = aspectObject();

package/dist/service/middlewareService.js

@@ -15,6 +15,8 @@ const interface_1 = require("../interface");
 const error_1 = require("../error");
 const util_1 = require("../util");
 const types_1 = require("../util/types");
+const util_2 = require("util");
+const debug = (0, util_2.debuglog)('midway:debug');
 let MidwayMiddlewareService = class MidwayMiddlewareService {
     constructor(applicationContext) {
         this.applicationContext = applicationContext;
@@ -89,6 +91,9 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                     fn = next;
                 if (!fn)
                     return Promise.resolve();
+                const middlewareName = `${name ? `${name}.` : ''}${index} ${fn._name || fn.name || 'anonymous'}`;
+                const startTime = Date.now();
+                debug(`[middleware]: in ${middlewareName} +0`);
                 try {
                     if (supportBody) {
                         return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
@@ -105,16 +110,21 @@ let MidwayMiddlewareService = class MidwayMiddlewareService {
                             else if (context['body'] !== undefined) {
                                 result = context['body'];
                             }
+                            debug(`[middleware]: out ${middlewareName} +${Date.now() - startTime} with body`);
                             return result;
                         });
                     }
                     else {
                         return Promise.resolve(fn(context, dispatch.bind(null, i + 1), {
                             index,
-                        }));
+                        })).then(result => {
+                            debug(`[middleware]: out ${middlewareName} +${Date.now() - startTime}`);
+                            return result;
+                        });
                     }
                 }
                 catch (err) {
+                    debug(`[middleware]: out ${middlewareName} +${Date.now() - startTime} with err ${err.message}`);
                     return Promise.reject(err);
                 }
             }

package/dist/util/index.d.ts

@@ -18,6 +18,7 @@ export declare const getCurrentEnvironment: () => string;
  */
 export declare const safeRequire: (p: any, enabledCache?: boolean) => any;
 /**
+ *  @example
  *  safelyGet(['a','b'],{a: {b: 2}})  // => 2
  *  safelyGet(['a','b'],{c: {b: 2}})  // => undefined
  *  safelyGet(['a','1'],{a: {"1": 2}})  // => 2

package/dist/util/index.js

@@ -55,6 +55,7 @@ const safeRequire = (p, enabledCache = true) => {
 };
 exports.safeRequire = safeRequire;
 /**
+ *  @example
  *  safelyGet(['a','b'],{a: {b: 2}})  // => 2
  *  safelyGet(['a','b'],{c: {b: 2}})  // => undefined
  *  safelyGet(['a','1'],{a: {"1": 2}})  // => 2

package/dist/util/pathFileUtil.d.ts

@@ -7,4 +7,5 @@ export declare const PathFileUtil: {
     isPathEqual: typeof isPathEqual;
     getFileContentSync: typeof getFileContentSync;
 };
+export declare function getModuleRequirePathList(moduleName: string): string[];
 //# sourceMappingURL=pathFileUtil.d.ts.map

package/dist/util/pathFileUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathFileUtil = exports.getFileContentSync = exports.isPathEqual = exports.isPath = void 0;
+exports.getModuleRequirePathList = exports.PathFileUtil = exports.getFileContentSync = exports.isPathEqual = exports.isPath = void 0;
 const path_1 = require("path");
 const fs_1 = require("fs");
 function isPath(p) {
@@ -32,4 +32,31 @@ exports.PathFileUtil = {
     isPathEqual,
     getFileContentSync,
 };
+function getModuleRequirePathList(moduleName) {
+    const moduleNameList = [moduleName, moduleName.replace(/\//g, '_')];
+    let moduleNameMap = {};
+    const modulePathList = [];
+    Object.keys(require.cache || {}).forEach(moduleName => {
+        let moduleIndex = -1;
+        for (const moduleName of moduleNameList) {
+            const index = moduleName.indexOf(moduleName);
+            if (index !== -1) {
+                moduleIndex = index;
+                break;
+            }
+        }
+        if (moduleIndex === -1) {
+            return;
+        }
+        const modulePath = moduleName.slice(0, moduleIndex);
+        if (moduleNameMap[modulePath]) {
+            return;
+        }
+        moduleNameMap[modulePath] = true;
+        modulePathList.push(modulePath);
+    });
+    moduleNameMap = undefined;
+    return modulePathList;
+}
+exports.getModuleRequirePathList = getModuleRequirePathList;
 //# sourceMappingURL=pathFileUtil.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.11.0",
+  "version": "3.11.4",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -23,7 +23,7 @@
   "license": "MIT",
   "devDependencies": {
     "koa": "2.14.1",
-    "mm": "3.2.1",
+    "mm": "3.2.2",
     "raw-body": "2.5.2",
     "sinon": "15.0.3"
   },
@@ -42,5 +42,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "eadb977e7fddcd4287c099fc32b601cd51702514"
+  "gitHead": "43dab73370ef7f9bf7778513ea4090a977b1f786"
 }