@midwayjs/core 3.0.0-alpha.6 → 3.0.0-beta.11

package/dist/setup.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destroyGlobalApplicationContext = exports.initializeGlobalApplicationContext = void 0;
+const _1 = require("./");
+const config_default_1 = require("./config/config.default");
+const decorator_1 = require("@midwayjs/decorator");
+const util = require("util");
+const path_1 = require("path");
+const logger_1 = require("@midwayjs/logger");
+const debug = util.debuglog('midway:debug');
+async function initializeGlobalApplicationContext(globalOptions) {
+    var _a, _b, _c, _d;
+    debug('[core]: start "initializeGlobalApplicationContext"');
+    const appDir = (_a = globalOptions.appDir) !== null && _a !== void 0 ? _a : '';
+    const baseDir = (_b = globalOptions.baseDir) !== null && _b !== void 0 ? _b : '';
+    // new container
+    const applicationContext = (_c = globalOptions.applicationContext) !== null && _c !== void 0 ? _c : new _1.MidwayContainer();
+    // bind container to decoratorManager
+    debug('[core]: delegate module map from decoratorManager');
+    (0, decorator_1.bindContainer)(applicationContext);
+    global['MIDWAY_APPLICATION_CONTEXT'] = applicationContext;
+    // register baseDir and appDir
+    applicationContext.registerObject('baseDir', baseDir);
+    applicationContext.registerObject('appDir', appDir);
+    if (globalOptions.moduleDetector !== false) {
+        if (globalOptions.moduleDetector === undefined ||
+            globalOptions.moduleDetector === 'file') {
+            applicationContext.setFileDetector(new _1.DirectoryFileDetector({
+                loadDir: baseDir,
+                ignore: (_d = globalOptions.ignore) !== null && _d !== void 0 ? _d : [],
+            }));
+        }
+        else if (globalOptions.moduleDetector) {
+            applicationContext.setFileDetector(globalOptions.moduleDetector);
+        }
+    }
+    // bind inner service
+    applicationContext.bindClass(_1.MidwayEnvironmentService);
+    applicationContext.bindClass(_1.MidwayInformationService);
+    applicationContext.bindClass(_1.MidwayDecoratorService);
+    applicationContext.bindClass(_1.MidwayConfigService);
+    applicationContext.bindClass(_1.MidwayAspectService);
+    applicationContext.bindClass(_1.MidwayLoggerService);
+    applicationContext.bindClass(_1.MidwayFrameworkService);
+    applicationContext.bindClass(_1.MidwayMiddlewareService);
+    applicationContext.bindClass(_1.MidwayLifeCycleService);
+    applicationContext.bindClass(_1.MidwayApplicationManager);
+    // bind preload module
+    if (globalOptions.preloadModules && globalOptions.preloadModules.length) {
+        for (const preloadModule of globalOptions.preloadModules) {
+            applicationContext.bindClass(preloadModule);
+        }
+    }
+    // init default config
+    const configService = await applicationContext.getAsync(_1.MidwayConfigService);
+    configService.add([
+        {
+            default: config_default_1.default,
+        },
+    ]);
+    // init aop support
+    await applicationContext.getAsync(_1.MidwayAspectService, [applicationContext]);
+    // init decorator service
+    await applicationContext.getAsync(_1.MidwayDecoratorService, [
+        applicationContext,
+    ]);
+    if (!globalOptions.configurationModule) {
+        globalOptions.configurationModule = [
+            (0, _1.safeRequire)((0, path_1.join)(globalOptions.baseDir, 'configuration')),
+        ];
+    }
+    for (const configurationModule of [].concat(globalOptions.configurationModule)) {
+        // load configuration and component
+        applicationContext.load(configurationModule);
+    }
+    // bind user code module
+    await applicationContext.ready();
+    if (globalOptions.globalConfig) {
+        if (Array.isArray(globalOptions.globalConfig)) {
+            configService.add(globalOptions.globalConfig);
+        }
+        else {
+            configService.addObject(globalOptions.globalConfig);
+        }
+    }
+    // merge config
+    await configService.load();
+    debug('[core]: Current config = %j', configService.getConfiguration());
+    // init logger
+    await applicationContext.getAsync(_1.MidwayLoggerService, [applicationContext]);
+    // middleware support
+    await applicationContext.getAsync(_1.MidwayMiddlewareService, [
+        applicationContext,
+    ]);
+    // framework/config/plugin/logger/app decorator support
+    await applicationContext.getAsync(_1.MidwayFrameworkService, [
+        applicationContext,
+        globalOptions,
+    ]);
+    // lifecycle support
+    await applicationContext.getAsync(_1.MidwayLifeCycleService, [
+        applicationContext,
+    ]);
+    return applicationContext;
+}
+exports.initializeGlobalApplicationContext = initializeGlobalApplicationContext;
+async function destroyGlobalApplicationContext(applicationContext) {
+    // stop lifecycle
+    const lifecycleService = await applicationContext.getAsync(_1.MidwayLifeCycleService);
+    await lifecycleService.stop();
+    // stop container
+    await applicationContext.stop();
+    (0, decorator_1.clearBindContainer)();
+    logger_1.loggers.close();
+    global['MIDWAY_APPLICATION_CONTEXT'] = undefined;
+    global['MIDWAY_MAIN_FRAMEWORK'] = undefined;
+}
+exports.destroyGlobalApplicationContext = destroyGlobalApplicationContext;
+//# sourceMappingURL=setup.js.map

package/dist/util/contextUtil.d.ts

@@ -1,5 +1,5 @@
 import { IConfigurationOptions, IMidwayContainer, IMidwayFramework } from '../interface';
 export declare const getCurrentApplicationContext: () => IMidwayContainer;
-export declare const getCurrentMainFramework: <APP extends import("../interface").IMidwayBaseApplication<import("../interface").Context>, T extends IConfigurationOptions>() => IMidwayFramework<APP, T>;
+export declare const getCurrentMainFramework: <APP extends import("../interface").IMidwayBaseApplication<CTX>, CTX extends import("../interface").Context, CONFIG extends IConfigurationOptions>() => IMidwayFramework<APP, CTX, CONFIG, unknown, unknown>;
 export declare const getCurrentMainApp: <APP extends import("../interface").IMidwayBaseApplication<import("../interface").Context>>() => APP;
 //# sourceMappingURL=contextUtil.d.ts.map

package/dist/util/contextUtil.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCurrentMainApp = exports.getCurrentMainFramework = exports.getCurrentApplicationContext = void 0;
 const getCurrentApplicationContext = () => {
-    return exports.getCurrentMainFramework().getApplicationContext();
+    return global['MIDWAY_APPLICATION_CONTEXT'];
 };
 exports.getCurrentApplicationContext = getCurrentApplicationContext;
 const getCurrentMainFramework = () => {
@@ -10,7 +10,7 @@ const getCurrentMainFramework = () => {
 };
 exports.getCurrentMainFramework = getCurrentMainFramework;
 const getCurrentMainApp = () => {
-    return exports.getCurrentMainFramework().getApplication();
+    return (0, exports.getCurrentMainFramework)().getApplication();
 };
 exports.getCurrentMainApp = getCurrentMainApp;
 //# sourceMappingURL=contextUtil.js.map

package/dist/util/index.d.ts

@@ -1,5 +1,18 @@
+import { FunctionMiddleware } from '../interface';
+/**
+ * @since 2.0.0
+ * @param env
+ */
 export declare const isDevelopmentEnvironment: (env: any) => boolean;
+/**
+ * @since 2.0.0
+ */
 export declare const getCurrentEnvironment: () => string;
+/**
+ * @param p
+ * @param enabledCache
+ * @since 2.0.0
+ */
 export declare const safeRequire: (p: any, enabledCache?: boolean) => any;
 /**
  *  safelyGet(['a','b'],{a: {b: 2}})  // => 2
@@ -8,14 +21,65 @@ export declare const safeRequire: (p: any, enabledCache?: boolean) => any;
  *  safelyGet(['a','1'],{a: {b: 2}})  // => undefined
  *  safelyGet('a.b',{a: {b: 2}})  // => 2
  *  safelyGet('a.b',{c: {b: 2}})  // => undefined
+ *  @since 2.0.0
  */
 export declare function safelyGet(list: string | string[], obj?: Record<string, unknown>): any;
 /**
  * 剔除 @ 符号
  * @param provideId provideId
+ * @since 2.0.0
  */
 export declare function parsePrefix(provideId: string): string;
 export declare function getUserHome(): string;
 export declare function joinURLPath(...strArray: any[]): string;
+/**
+ * 代理目标所有的原型方法，不包括构造器和内部隐藏方法
+ * @param derivedCtor
+ * @param constructors
+ * @since 2.0.0
+ */
 export declare function delegateTargetPrototypeMethod(derivedCtor: any, constructors: any[]): void;
+/**
+ * 代理目标原型上的特定方法
+ * @param derivedCtor
+ * @param methods
+ * @since 2.0.0
+ */
+export declare function delegateTargetMethod(derivedCtor: any, methods: string[]): void;
+/**
+ * 代理目标原型属性
+ * @param derivedCtor
+ * @param properties
+ * @since 2.0.0
+ */
+export declare function delegateTargetProperties(derivedCtor: any, properties: string[]): void;
+/**
+ * 代理目标原型属性
+ * @since 2.0.0
+ * @param timestamp
+ */
+export declare const getCurrentDateString: (timestamp?: number) => string;
+/**
+ *
+ * @param message
+ * @since 3.0.0
+ */
+export declare const deprecatedOutput: (message: string) => void;
+/**
+ * transform request object to definition type
+ *
+ * @param originValue
+ * @param targetType
+ * @since 3.0.0
+ */
+export declare const transformRequestObjectByType: (originValue: any, targetType?: any) => any;
+export declare function toPathMatch(pattern: any): any;
+export declare function pathMatching(options: any): (ctx?: any) => any;
+/**
+ * wrap function middleware with match and ignore
+ * @param mw
+ * @param options
+ */
+export declare function wrapMiddleware(mw: FunctionMiddleware<any, any>, options: any): (context: any, next: any, options?: any) => any;
+export declare function isIncludeProperty(obj: any, prop: string): boolean;
 //# sourceMappingURL=index.d.ts.map

package/dist/util/index.js

@@ -1,36 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
+exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
 const path_1 = require("path");
 const fs_1 = require("fs");
 const util_1 = require("util");
-const debug = util_1.debuglog('midway:container:util');
+const transformer = require("class-transformer");
+const pathToRegexp_1 = require("./pathToRegexp");
+const error_1 = require("../error");
+const debug = (0, util_1.debuglog)('midway:container:util');
+/**
+ * @since 2.0.0
+ * @param env
+ */
 const isDevelopmentEnvironment = env => {
     return ['local', 'test', 'unittest'].includes(env);
 };
 exports.isDevelopmentEnvironment = isDevelopmentEnvironment;
+/**
+ * @since 2.0.0
+ */
 const getCurrentEnvironment = () => {
     return process.env['MIDWAY_SERVER_ENV'] || process.env['NODE_ENV'] || 'prod';
 };
 exports.getCurrentEnvironment = getCurrentEnvironment;
+/**
+ * @param p
+ * @param enabledCache
+ * @since 2.0.0
+ */
 const safeRequire = (p, enabledCache = true) => {
     if (p.startsWith(`.${path_1.sep}`) || p.startsWith(`..${path_1.sep}`)) {
-        p = path_1.resolve(path_1.dirname(module.parent.filename), p);
+        p = (0, path_1.resolve)((0, path_1.dirname)(module.parent.filename), p);
     }
     try {
         if (enabledCache) {
             return require(p);
         }
         else {
-            const content = fs_1.readFileSync(p, {
+            const content = (0, fs_1.readFileSync)(p, {
                 encoding: 'utf-8',
             });
             return JSON.parse(content);
         }
     }
     catch (err) {
-        debug('SafeRequire Warning');
-        debug(err);
+        debug(`SafeRequire Warning, message = ${err.message}`);
         return undefined;
     }
 };
@@ -42,6 +56,7 @@ exports.safeRequire = safeRequire;
  *  safelyGet(['a','1'],{a: {b: 2}})  // => undefined
  *  safelyGet('a.b',{a: {b: 2}})  // => 2
  *  safelyGet('a.b',{c: {b: 2}})  // => undefined
+ *  @since 2.0.0
  */
 function safelyGet(list, obj) {
     if (arguments.length === 1) {
@@ -67,6 +82,7 @@ exports.safelyGet = safelyGet;
 /**
  * 剔除 @ 符号
  * @param provideId provideId
+ * @since 2.0.0
  */
 function parsePrefix(provideId) {
     if (provideId.includes('@')) {
@@ -80,6 +96,7 @@ function getUserHome() {
 }
 exports.getUserHome = getUserHome;
 function joinURLPath(...strArray) {
+    strArray = strArray.filter(item => !!item);
     if (strArray.length === 0) {
         return '';
     }
@@ -91,11 +108,17 @@ function joinURLPath(...strArray) {
     return p;
 }
 exports.joinURLPath = joinURLPath;
+/**
+ * 代理目标所有的原型方法，不包括构造器和内部隐藏方法
+ * @param derivedCtor
+ * @param constructors
+ * @since 2.0.0
+ */
 function delegateTargetPrototypeMethod(derivedCtor, constructors) {
     constructors.forEach(baseCtor => {
         Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
             if (name !== 'constructor' && !/^_/.test(name)) {
-                derivedCtor.prototype[name] = async function (...args) {
+                derivedCtor.prototype[name] = function (...args) {
                     return this.instance[name](...args);
                 };
             }
@@ -103,4 +126,169 @@ function delegateTargetPrototypeMethod(derivedCtor, constructors) {
     });
 }
 exports.delegateTargetPrototypeMethod = delegateTargetPrototypeMethod;
+/**
+ * 代理目标原型上的特定方法
+ * @param derivedCtor
+ * @param methods
+ * @since 2.0.0
+ */
+function delegateTargetMethod(derivedCtor, methods) {
+    methods.forEach(name => {
+        derivedCtor.prototype[name] = function (...args) {
+            return this.instance[name](...args);
+        };
+    });
+}
+exports.delegateTargetMethod = delegateTargetMethod;
+/**
+ * 代理目标原型属性
+ * @param derivedCtor
+ * @param properties
+ * @since 2.0.0
+ */
+function delegateTargetProperties(derivedCtor, properties) {
+    properties.forEach(name => {
+        Object.defineProperty(derivedCtor.prototype, name, {
+            get() {
+                return this.instance[name];
+            },
+        });
+    });
+}
+exports.delegateTargetProperties = delegateTargetProperties;
+/**
+ * 代理目标原型属性
+ * @since 2.0.0
+ * @param timestamp
+ */
+const getCurrentDateString = (timestamp = Date.now()) => {
+    const d = new Date(timestamp);
+    return `${d.getFullYear()}-${(d.getMonth() + 1)
+        .toString()
+        .padStart(2, '0')}-${d.getDate().toString().padStart(2, '0')}`;
+};
+exports.getCurrentDateString = getCurrentDateString;
+/**
+ *
+ * @param message
+ * @since 3.0.0
+ */
+const deprecatedOutput = (message) => {
+    console.warn('DeprecationWarning: ' + message);
+};
+exports.deprecatedOutput = deprecatedOutput;
+/**
+ * transform request object to definition type
+ *
+ * @param originValue
+ * @param targetType
+ * @since 3.0.0
+ */
+const transformRequestObjectByType = (originValue, targetType) => {
+    if (targetType === undefined ||
+        targetType === null ||
+        targetType === Object) {
+        return originValue;
+    }
+    switch (targetType) {
+        case Number:
+            return Number(originValue);
+        case String:
+            return String(originValue);
+        case Boolean:
+            if (originValue === '0' || originValue === 'false') {
+                return false;
+            }
+            return Boolean(originValue);
+        default:
+            if (originValue instanceof targetType) {
+                return originValue;
+            }
+            else {
+                const transformToInstance = transformer['plainToClass'] || transformer['plainToInstance'];
+                return transformToInstance(targetType, originValue);
+            }
+    }
+};
+exports.transformRequestObjectByType = transformRequestObjectByType;
+function toPathMatch(pattern) {
+    if (typeof pattern === 'boolean') {
+        return ctx => pattern;
+    }
+    if (typeof pattern === 'string') {
+        const reg = (0, pathToRegexp_1.pathToRegexp)(pattern, [], { end: false });
+        if (reg.global)
+            reg.lastIndex = 0;
+        return ctx => reg.test(ctx.path);
+    }
+    if (pattern instanceof RegExp) {
+        return ctx => {
+            if (pattern.global)
+                pattern.lastIndex = 0;
+            return pattern.test(ctx.path);
+        };
+    }
+    if (typeof pattern === 'function')
+        return pattern;
+    if (Array.isArray(pattern)) {
+        const matchs = pattern.map(item => toPathMatch(item));
+        return ctx => matchs.some(match => match(ctx));
+    }
+    throw new error_1.MidwayCommonError('match/ignore pattern must be RegExp, Array or String, but got ' + pattern);
+}
+exports.toPathMatch = toPathMatch;
+function pathMatching(options) {
+    options = options || {};
+    if (options.match && options.ignore)
+        throw new error_1.MidwayCommonError('options.match and options.ignore can not both present');
+    if (!options.match && !options.ignore)
+        return () => true;
+    const matchFn = options.match
+        ? toPathMatch(options.match)
+        : toPathMatch(options.ignore);
+    return function pathMatch(ctx) {
+        const matched = matchFn(ctx);
+        return options.match ? matched : !matched;
+    };
+}
+exports.pathMatching = pathMatching;
+/**
+ * wrap function middleware with match and ignore
+ * @param mw
+ * @param options
+ */
+function wrapMiddleware(mw, options) {
+    // support options.enable
+    if (options.enable === false)
+        return null;
+    // support options.match and options.ignore
+    if (!options.match && !options.ignore)
+        return mw;
+    const match = pathMatching(options);
+    const fn = (ctx, next) => {
+        if (!match(ctx))
+            return next();
+        return mw(ctx, next);
+    };
+    fn._name = mw._name + 'middlewareWrapper';
+    return fn;
+}
+exports.wrapMiddleware = wrapMiddleware;
+function isOwnPropertyWritable(obj, prop) {
+    if (obj == null)
+        return false;
+    const type = typeof obj;
+    if (type !== 'object' && type !== 'function')
+        return false;
+    return !!Object.getOwnPropertyDescriptor(obj, prop);
+}
+function isIncludeProperty(obj, prop) {
+    while (obj) {
+        if (isOwnPropertyWritable(obj, prop))
+            return true;
+        obj = Object.getPrototypeOf(obj);
+    }
+    return false;
+}
+exports.isIncludeProperty = isIncludeProperty;
 //# sourceMappingURL=index.js.map

package/dist/util/pathFileUtil.js

@@ -15,12 +15,12 @@ exports.PathFileUtil = {
         if (!one || !two) {
             return false;
         }
-        const ext = path_1.extname(one);
+        const ext = (0, path_1.extname)(one);
         return one.replace(ext, '') === two;
     },
     getFileContentSync(filePath, encoding) {
         return typeof filePath === 'string'
-            ? fs_1.readFileSync(filePath, {
+            ? (0, fs_1.readFileSync)(filePath, {
                 encoding,
             })
             : filePath;

package/dist/util/pathToRegexp.d.ts

@@ -0,0 +1,17 @@
+/**
+ * this file fork from path-to-regexp package v1.8.0
+ */
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ *
+ * @param  {(string|RegExp|Array)} path
+ * @param  {(Array|Object)=}       keys
+ * @param  {Object=}               options
+ * @return {!RegExp}
+ */
+export declare function pathToRegexp(path: any, keys: any, options: any): any;
+//# sourceMappingURL=pathToRegexp.d.ts.map