@midwayjs/core 3.0.0-alpha.43 → 3.0.0-beta.10

package/dist/util/index.js

@@ -1,18 +1,33 @@
 "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 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 = (0, path_1.resolve)((0, path_1.dirname)(module.parent.filename), p);
@@ -29,8 +44,7 @@ const safeRequire = (p, enabledCache = true) => {
         }
     }
     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/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

package/dist/util/pathToRegexp.js

@@ -0,0 +1,280 @@
+"use strict";
+/**
+ * this file fork from path-to-regexp package v1.8.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathToRegexp = void 0;
+/**
+ * The main path matching regexp utility.
+ *
+ * @type {RegExp}
+ */
+const PATH_REGEXP = new RegExp([
+    // Match escaped characters that would otherwise appear in future matches.
+    // This allows the user to escape special characters that won't transform.
+    '(\\\\.)',
+    // Match Express-style parameters and un-named parameters with a prefix
+    // and optional suffixes. Matches appear as:
+    //
+    // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?", undefined]
+    // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined, undefined]
+    // "/*"            => ["/", undefined, undefined, undefined, undefined, "*"]
+    '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))',
+].join('|'), 'g');
+/**
+ * Parse a string for the raw tokens.
+ *
+ * @param  {string}  str
+ * @param  {Object=} options
+ * @return {!Array}
+ */
+function parse(str, options) {
+    const tokens = [];
+    let key = 0;
+    let index = 0;
+    let path = '';
+    const defaultDelimiter = (options && options.delimiter) || '/';
+    let res;
+    while ((res = PATH_REGEXP.exec(str)) != null) {
+        const m = res[0];
+        const escaped = res[1];
+        const offset = res.index;
+        path += str.slice(index, offset);
+        index = offset + m.length;
+        // Ignore already escaped sequences.
+        if (escaped) {
+            path += escaped[1];
+            continue;
+        }
+        const next = str[index];
+        const prefix = res[2];
+        const name = res[3];
+        const capture = res[4];
+        const group = res[5];
+        const modifier = res[6];
+        const asterisk = res[7];
+        // Push the current path onto the tokens.
+        if (path) {
+            tokens.push(path);
+            path = '';
+        }
+        const partial = prefix != null && next != null && next !== prefix;
+        const repeat = modifier === '+' || modifier === '*';
+        const optional = modifier === '?' || modifier === '*';
+        const delimiter = res[2] || defaultDelimiter;
+        const pattern = capture || group;
+        tokens.push({
+            name: name || key++,
+            prefix: prefix || '',
+            delimiter: delimiter,
+            optional: optional,
+            repeat: repeat,
+            partial: partial,
+            asterisk: !!asterisk,
+            pattern: pattern
+                ? escapeGroup(pattern)
+                : asterisk
+                    ? '.*'
+                    : '[^' + escapeString(delimiter) + ']+?',
+        });
+    }
+    // Match any characters still remaining.
+    if (index < str.length) {
+        path += str.substr(index);
+    }
+    // If the path exists, push it onto the end.
+    if (path) {
+        tokens.push(path);
+    }
+    return tokens;
+}
+/**
+ * Escape a regular expression string.
+ *
+ * @param  {string} str
+ * @return {string}
+ */
+function escapeString(str) {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+}
+/**
+ * Escape the capturing group by escaping special characters and meaning.
+ *
+ * @param  {string} group
+ * @return {string}
+ */
+function escapeGroup(group) {
+    return group.replace(/([=!:$/()])/g, '\\$1');
+}
+/**
+ * Attach the keys as a property of the regexp.
+ *
+ * @param  {!RegExp} re
+ * @param  {Array}   keys
+ * @return {!RegExp}
+ */
+function attachKeys(re, keys) {
+    re.keys = keys;
+    return re;
+}
+/**
+ * Get the flags for a regexp from the options.
+ *
+ * @param  {Object} options
+ * @return {string}
+ */
+function flags(options) {
+    return options && options.sensitive ? '' : 'i';
+}
+/**
+ * Pull out keys from a regexp.
+ *
+ * @param  {!RegExp} path
+ * @param  {!Array}  keys
+ * @return {!RegExp}
+ */
+function regexpToRegexp(path, keys) {
+    // Use a negative lookahead to match only capturing groups.
+    const groups = path.source.match(/\((?!\?)/g);
+    if (groups) {
+        for (let i = 0; i < groups.length; i++) {
+            keys.push({
+                name: i,
+                prefix: null,
+                delimiter: null,
+                optional: false,
+                repeat: false,
+                partial: false,
+                asterisk: false,
+                pattern: null,
+            });
+        }
+    }
+    return attachKeys(path, keys);
+}
+/**
+ * Transform an array into a regexp.
+ *
+ * @param  {!Array}  path
+ * @param  {Array}   keys
+ * @param  {!Object} options
+ * @return {!RegExp}
+ */
+function arrayToRegexp(path, keys, options) {
+    const parts = [];
+    for (let i = 0; i < path.length; i++) {
+        parts.push(pathToRegexp(path[i], keys, options).source);
+    }
+    const regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
+    return attachKeys(regexp, keys);
+}
+/**
+ * Create a path regexp from string input.
+ *
+ * @param  {string}  path
+ * @param  {!Array}  keys
+ * @param  {!Object} options
+ * @return {!RegExp}
+ */
+function stringToRegexp(path, keys, options) {
+    return tokensToRegExp(parse(path, options), keys, options);
+}
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ *
+ * @param  {!Array}          tokens
+ * @param  {(Array|Object)=} keys
+ * @param  {Object=}         options
+ * @return {!RegExp}
+ */
+function tokensToRegExp(tokens, keys, options) {
+    if (!Array.isArray(keys)) {
+        options = /** @type {!Object} */ keys || options;
+        keys = [];
+    }
+    options = options || {};
+    const strict = options.strict;
+    const end = options.end !== false;
+    let route = '';
+    // Iterate over the tokens and create our regexp string.
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (typeof token === 'string') {
+            route += escapeString(token);
+        }
+        else {
+            const prefix = escapeString(token.prefix);
+            let capture = '(?:' + token.pattern + ')';
+            keys.push(token);
+            if (token.repeat) {
+                capture += '(?:' + prefix + capture + ')*';
+            }
+            if (token.optional) {
+                if (!token.partial) {
+                    capture = '(?:' + prefix + '(' + capture + '))?';
+                }
+                else {
+                    capture = prefix + '(' + capture + ')?';
+                }
+            }
+            else {
+                capture = prefix + '(' + capture + ')';
+            }
+            route += capture;
+        }
+    }
+    const delimiter = escapeString(options.delimiter || '/');
+    const endsWithDelimiter = route.slice(-delimiter.length) === delimiter;
+    // In non-strict mode we allow a slash at the end of match. If the path to
+    // match already ends with a slash, we remove it for consistency. The slash
+    // is valid at the end of a path match, not in the middle. This is important
+    // in non-ending mode, where "/test/" shouldn't match "/test//route".
+    if (!strict) {
+        route =
+            (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) +
+                '(?:' +
+                delimiter +
+                '(?=$))?';
+    }
+    if (end) {
+        route += '$';
+    }
+    else {
+        // In non-ending mode, we need the capturing groups to match as much as
+        // possible by using a positive lookahead to the end or next path segment.
+        route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
+    }
+    return attachKeys(new RegExp('^' + route, flags(options)), keys);
+}
+/**
+ * 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}
+ */
+function pathToRegexp(path, keys, options) {
+    if (!Array.isArray(keys)) {
+        options = /** @type {!Object} */ keys || options;
+        keys = [];
+    }
+    options = options || {};
+    if (path instanceof RegExp) {
+        return regexpToRegexp(path, /** @type {!Array} */ keys);
+    }
+    if (Array.isArray(path)) {
+        return arrayToRegexp(
+        /** @type {!Array} */ path, 
+        /** @type {!Array} */ keys, options);
+    }
+    return stringToRegexp(
+    /** @type {string} */ path, 
+    /** @type {!Array} */ keys, options);
+}
+exports.pathToRegexp = pathToRegexp;
+//# sourceMappingURL=pathToRegexp.js.map

package/dist/util/webRouterParam.d.ts

@@ -1,3 +1,3 @@
-export declare const extractKoaLikeValue: (key: any, data: any) => (ctx: any, next: any) => Promise<any>;
-export declare const extractExpressLikeValue: (key: any, data: any) => (req: any, res: any, next: any) => Promise<any>;
+export declare const extractKoaLikeValue: (key: any, data: any, paramType?: any) => (ctx: any, next: any) => any;
+export declare const extractExpressLikeValue: (key: any, data: any, paramType?: any) => (req: any, res: any, next: any) => any;
 //# sourceMappingURL=webRouterParam.d.ts.map

package/dist/util/webRouterParam.js

@@ -2,26 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractExpressLikeValue = exports.extractKoaLikeValue = void 0;
 const decorator_1 = require("@midwayjs/decorator");
-const extractKoaLikeValue = (key, data) => {
+const index_1 = require("./index");
+const extractKoaLikeValue = (key, data, paramType) => {
     if (decorator_1.ALL === data) {
         data = undefined;
     }
-    return async function (ctx, next) {
+    return function (ctx, next) {
         switch (key) {
             case decorator_1.RouteParamTypes.NEXT:
                 return next;
             case decorator_1.RouteParamTypes.BODY:
-                return data && ctx.request.body
-                    ? ctx.request.body[data]
-                    : ctx.request.body;
+                return (0, index_1.transformRequestObjectByType)(data && ctx.request.body ? ctx.request.body[data] : ctx.request.body, paramType);
             case decorator_1.RouteParamTypes.PARAM:
-                return data ? ctx.params[data] : ctx.params;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.params[data] : ctx.params, paramType);
             case decorator_1.RouteParamTypes.QUERY:
-                return data ? ctx.query[data] : ctx.query;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.query[data] : ctx.query, paramType);
             case decorator_1.RouteParamTypes.HEADERS:
-                return data ? ctx.get(data) : ctx.headers;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.get(data) : ctx.headers, paramType);
             case decorator_1.RouteParamTypes.SESSION:
-                return data ? ctx.session[data] : ctx.session;
+                return (0, index_1.transformRequestObjectByType)(data ? ctx.session[data] : ctx.session, paramType);
             case decorator_1.RouteParamTypes.FILESTREAM:
                 return ctx.getFileStream && ctx.getFileStream(data);
             case decorator_1.RouteParamTypes.FILESSTREAM:
@@ -32,10 +31,10 @@ const extractKoaLikeValue = (key, data) => {
                 return ctx['ip'];
             case decorator_1.RouteParamTypes.QUERIES:
                 if (ctx.queries) {
-                    return data ? ctx.queries[data] : ctx.queries;
+                    return (0, index_1.transformRequestObjectByType)(data ? ctx.queries[data] : ctx.queries, paramType);
                 }
                 else {
-                    return data ? ctx.query[data] : ctx.query;
+                    return (0, index_1.transformRequestObjectByType)(data ? ctx.query[data] : ctx.query, paramType);
                 }
             default:
                 return null;
@@ -43,24 +42,24 @@ const extractKoaLikeValue = (key, data) => {
     };
 };
 exports.extractKoaLikeValue = extractKoaLikeValue;
-const extractExpressLikeValue = (key, data) => {
+const extractExpressLikeValue = (key, data, paramType) => {
     if (decorator_1.ALL === data) {
         data = undefined;
     }
-    return async function (req, res, next) {
+    return function (req, res, next) {
         switch (key) {
             case decorator_1.RouteParamTypes.NEXT:
                 return next;
             case decorator_1.RouteParamTypes.BODY:
-                return data && req.body ? req.body[data] : req.body;
+                return (0, index_1.transformRequestObjectByType)(data && req.body ? req.body[data] : req.body, paramType);
             case decorator_1.RouteParamTypes.PARAM:
-                return data ? req.params[data] : req.params;
+                return (0, index_1.transformRequestObjectByType)(data ? req.params[data] : req.params, paramType);
             case decorator_1.RouteParamTypes.QUERY:
-                return data ? req.query[data] : req.query;
+                return (0, index_1.transformRequestObjectByType)(data ? req.query[data] : req.query, paramType);
             case decorator_1.RouteParamTypes.HEADERS:
-                return data ? req.get(data) : req.headers;
+                return (0, index_1.transformRequestObjectByType)(data ? req.get(data) : req.headers, paramType);
             case decorator_1.RouteParamTypes.SESSION:
-                return data ? req.session[data] : req.session;
+                return (0, index_1.transformRequestObjectByType)(data ? req.session[data] : req.session, paramType);
             case decorator_1.RouteParamTypes.FILESTREAM:
                 return req.getFileStream && req.getFileStream(data);
             case decorator_1.RouteParamTypes.FILESSTREAM:
@@ -71,10 +70,10 @@ const extractExpressLikeValue = (key, data) => {
                 return req['ip'];
             case decorator_1.RouteParamTypes.QUERIES:
                 if (req.queries) {
-                    return data ? req.queries[data] : req.queries;
+                    return (0, index_1.transformRequestObjectByType)(data ? req.queries[data] : req.queries, paramType);
                 }
                 else {
-                    return data ? req.query[data] : req.query;
+                    return (0, index_1.transformRequestObjectByType)(data ? req.query[data] : req.query, paramType);
                 }
             default:
                 return null;