@midwayjs/core 3.5.4-beta.2 → 3.6.0

package/dist/util/index.js

@@ -1,12 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapAsync = exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetAllPrototypeMethod = exports.delegateTargetPrototypeMethod = exports.joinURLPath = exports.getUserHome = exports.parsePrefix = exports.safelyGet = exports.safeRequire = exports.getCurrentEnvironment = exports.isDevelopmentEnvironment = void 0;
+exports.Utils = exports.toAsyncFunction = exports.merge = exports.generateRandomId = exports.getParamNames = exports.sleep = exports.wrapAsync = exports.isIncludeProperty = exports.wrapMiddleware = exports.pathMatching = exports.toPathMatch = exports.transformRequestObjectByType = exports.deprecatedOutput = exports.getCurrentDateString = exports.delegateTargetProperties = exports.delegateTargetMethod = exports.delegateTargetAllPrototypeMethod = 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 camelCase_1 = require("./camelCase");
+const uuid_1 = require("./uuid");
+const flatted_1 = require("./flatted");
+const crypto = require("crypto");
+const types_1 = require("./types");
 const debug = (0, util_1.debuglog)('midway:container:util');
 /**
  * @since 2.0.0
@@ -334,4 +339,78 @@ function wrapAsync(handler) {
     };
 }
 exports.wrapAsync = wrapAsync;
+function sleep(sleepTime = 1000) {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve();
+        }, sleepTime);
+    });
+}
+exports.sleep = sleep;
+const STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+/**
+ * get parameter name from function
+ * @param func
+ */
+function getParamNames(func) {
+    const fnStr = func.toString().replace(STRIP_COMMENTS, '');
+    let result = fnStr
+        .slice(fnStr.indexOf('(') + 1, fnStr.indexOf(')'))
+        .split(',')
+        .map(content => {
+        return content.trim().replace(/\s?=.*$/, '');
+    });
+    if (result.length === 1 && result[0] === '') {
+        result = [];
+    }
+    return result;
+}
+exports.getParamNames = getParamNames;
+/**
+ * generate a lightweight 32 bit random id, enough for ioc container
+ */
+function generateRandomId() {
+    // => f9b327e70bbcf42494ccb28b2d98e00e
+    return crypto.randomBytes(16).toString('hex');
+}
+exports.generateRandomId = generateRandomId;
+function merge(target, src) {
+    if (!target) {
+        target = src;
+        src = null;
+    }
+    if (!target) {
+        return null;
+    }
+    if (Array.isArray(target)) {
+        return target.concat(src || []);
+    }
+    if (typeof target === 'object') {
+        return Object.assign({}, target, src);
+    }
+    throw new Error('can not merge meta that type of ' + typeof target);
+}
+exports.merge = merge;
+function toAsyncFunction(method) {
+    if (types_1.Types.isAsyncFunction(method)) {
+        return method;
+    }
+    else {
+        return async function (...args) {
+            return Promise.resolve(method.call(this, ...args));
+        };
+    }
+}
+exports.toAsyncFunction = toAsyncFunction;
+exports.Utils = {
+    sleep,
+    getParamNames,
+    camelCase: camelCase_1.camelCase,
+    pascalCase: camelCase_1.pascalCase,
+    randomUUID: uuid_1.randomUUID,
+    generateRandomId,
+    toAsyncFunction,
+    safeStringify: flatted_1.safeStringify,
+    safeParse: flatted_1.safeParse,
+};
 //# sourceMappingURL=index.js.map

package/dist/util/pathFileUtil.d.ts

@@ -1,7 +1,10 @@
 /// <reference types="node" />
+export declare function isPath(p: any): boolean;
+export declare function isPathEqual(one: string, two: string): boolean;
+export declare function getFileContentSync(filePath: any, encoding?: BufferEncoding): any;
 export declare const PathFileUtil: {
-    isPath(p: any): boolean;
-    isPathEqual(one: string, two: string): boolean;
-    getFileContentSync(filePath: any, encoding?: BufferEncoding): any;
+    isPath: typeof isPath;
+    isPathEqual: typeof isPathEqual;
+    getFileContentSync: typeof getFileContentSync;
 };
 //# sourceMappingURL=pathFileUtil.d.ts.map

package/dist/util/pathFileUtil.js

@@ -1,29 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathFileUtil = void 0;
+exports.PathFileUtil = exports.getFileContentSync = exports.isPathEqual = exports.isPath = void 0;
 const path_1 = require("path");
 const fs_1 = require("fs");
-exports.PathFileUtil = {
-    isPath(p) {
-        // eslint-disable-next-line no-useless-escape
-        if (/(^[\.\/])|:|\\/.test(p)) {
-            return true;
-        }
+function isPath(p) {
+    // eslint-disable-next-line no-useless-escape
+    if (/(^[\.\/])|:|\\/.test(p)) {
+        return true;
+    }
+    return false;
+}
+exports.isPath = isPath;
+function isPathEqual(one, two) {
+    if (!one || !two) {
         return false;
-    },
-    isPathEqual(one, two) {
-        if (!one || !two) {
-            return false;
-        }
-        const ext = (0, path_1.extname)(one);
-        return one.replace(ext, '') === two;
-    },
-    getFileContentSync(filePath, encoding) {
-        return typeof filePath === 'string'
-            ? (0, fs_1.readFileSync)(filePath, {
-                encoding,
-            })
-            : filePath;
-    },
+    }
+    const ext = (0, path_1.extname)(one);
+    return one.replace(ext, '') === two;
+}
+exports.isPathEqual = isPathEqual;
+function getFileContentSync(filePath, encoding) {
+    return typeof filePath === 'string'
+        ? (0, fs_1.readFileSync)(filePath, {
+            encoding,
+        })
+        : filePath;
+}
+exports.getFileContentSync = getFileContentSync;
+exports.PathFileUtil = {
+    isPath,
+    isPathEqual,
+    getFileContentSync,
 };
 //# sourceMappingURL=pathFileUtil.js.map

package/dist/util/retry.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.retryWith = exports.retryWithAsync = void 0;
+const _1 = require(".");
 const error_1 = require("../error");
-const decorator_1 = require("@midwayjs/decorator");
 /**
  * wrap async function with retry
  * @param retryFn
@@ -21,7 +21,7 @@ function retryWithAsync(retryFn, retryTimes = 1, options = {}) {
                 error = err;
             }
             if (options.retryInterval >= 0) {
-                await (0, decorator_1.sleep)(options.retryInterval);
+                await (0, _1.sleep)(options.retryInterval);
             }
         } while (defaultRetry-- > 0);
         if (options.throwOriginError) {

package/dist/util/types.d.ts

@@ -0,0 +1,35 @@
+export declare function isString(value: any): boolean;
+export declare function isClass(fn: any): boolean;
+export declare function isAsyncFunction(value: any): boolean;
+export declare function isGeneratorFunction(value: any): boolean;
+export declare function isPromise(value: any): boolean;
+export declare function isFunction(value: any): boolean;
+export declare function isObject(value: any): boolean;
+export declare function isPlainObject(obj: any): any;
+export declare function isNumber(value: any): boolean;
+export declare function isProxy(value: any): boolean;
+export declare function isMap(value: any): boolean;
+export declare function isSet(value: any): boolean;
+export declare function isRegExp(value: any): boolean;
+export declare function isUndefined(value: any): boolean;
+export declare function isNull(value: any): boolean;
+export declare function isNullOrUndefined(value: any): boolean;
+export declare const Types: {
+    isClass: typeof isClass;
+    isAsyncFunction: typeof isAsyncFunction;
+    isGeneratorFunction: typeof isGeneratorFunction;
+    isString: typeof isString;
+    isPromise: typeof isPromise;
+    isFunction: typeof isFunction;
+    isObject: typeof isObject;
+    isPlainObject: typeof isPlainObject;
+    isNumber: typeof isNumber;
+    isProxy: typeof isProxy;
+    isMap: typeof isMap;
+    isSet: typeof isSet;
+    isRegExp: typeof isRegExp;
+    isUndefined: typeof isUndefined;
+    isNull: typeof isNull;
+    isNullOrUndefined: typeof isNullOrUndefined;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/util/types.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Types = exports.isNullOrUndefined = exports.isNull = exports.isUndefined = exports.isRegExp = exports.isSet = exports.isMap = exports.isProxy = exports.isNumber = exports.isPlainObject = exports.isObject = exports.isFunction = exports.isPromise = exports.isGeneratorFunction = exports.isAsyncFunction = exports.isClass = exports.isString = void 0;
+const util = require("util");
+const ToString = Function.prototype.toString;
+const hasOwn = Object.prototype.hasOwnProperty;
+const toStr = Object.prototype.toString;
+function fnBody(fn) {
+    return ToString.call(fn)
+        .replace(/^[^{]*{\s*/, '')
+        .replace(/\s*}[^}]*$/, '');
+}
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
+function isClass(fn) {
+    if (typeof fn !== 'function') {
+        return false;
+    }
+    if (/^class[\s{]/.test(ToString.call(fn))) {
+        return true;
+    }
+    // babel.js classCallCheck() & inlined
+    const body = fnBody(fn);
+    return (/classCallCheck\(/.test(body) ||
+        /TypeError\("Cannot call a class as a function"\)/.test(body));
+}
+exports.isClass = isClass;
+function isAsyncFunction(value) {
+    return util.types.isAsyncFunction(value);
+}
+exports.isAsyncFunction = isAsyncFunction;
+function isGeneratorFunction(value) {
+    return util.types.isGeneratorFunction(value);
+}
+exports.isGeneratorFunction = isGeneratorFunction;
+function isPromise(value) {
+    return util.types.isPromise(value);
+}
+exports.isPromise = isPromise;
+function isFunction(value) {
+    return typeof value === 'function';
+}
+exports.isFunction = isFunction;
+function isObject(value) {
+    return value !== null && typeof value === 'object';
+}
+exports.isObject = isObject;
+function isPlainObject(obj) {
+    if (!obj || toStr.call(obj) !== '[object Object]') {
+        return false;
+    }
+    const hasOwnConstructor = hasOwn.call(obj, 'constructor');
+    const hasIsPrototypeOf = obj.constructor &&
+        obj.constructor.prototype &&
+        hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+    // Not own constructor property must be Object
+    if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+        return false;
+    }
+    // Own properties are enumerated firstly, so to speed up,
+    // if last one is own, then all properties are own.
+    let key;
+    for (key in obj) {
+        /**/
+    }
+    return typeof key === 'undefined' || hasOwn.call(obj, key);
+}
+exports.isPlainObject = isPlainObject;
+function isNumber(value) {
+    return typeof value === 'number';
+}
+exports.isNumber = isNumber;
+function isProxy(value) {
+    return util.types.isProxy(value);
+}
+exports.isProxy = isProxy;
+function isMap(value) {
+    return util.types.isMap(value);
+}
+exports.isMap = isMap;
+function isSet(value) {
+    return util.types.isSet(value);
+}
+exports.isSet = isSet;
+function isRegExp(value) {
+    return util.types.isRegExp(value);
+}
+exports.isRegExp = isRegExp;
+function isUndefined(value) {
+    return value === undefined;
+}
+exports.isUndefined = isUndefined;
+function isNull(value) {
+    return value === null;
+}
+exports.isNull = isNull;
+function isNullOrUndefined(value) {
+    return isUndefined(value) || isNull(value);
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.Types = {
+    isClass,
+    isAsyncFunction,
+    isGeneratorFunction,
+    isString,
+    isPromise,
+    isFunction,
+    isObject,
+    isPlainObject,
+    isNumber,
+    isProxy,
+    isMap,
+    isSet,
+    isRegExp,
+    isUndefined,
+    isNull,
+    isNullOrUndefined,
+};
+//# sourceMappingURL=types.js.map

package/dist/util/uuid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * a easy uuid v4 generator
+ */
+export declare function randomUUID(force?: boolean): string;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/util/uuid.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomUUID = void 0;
+const crypto = require("crypto");
+/**
+ * code fork from https://github.com/uuidjs/uuid/blob/main/src/stringify.js
+ */
+const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate
+let poolPtr = rnds8Pool.length;
+function rng() {
+    if (poolPtr > rnds8Pool.length - 16) {
+        crypto.randomFillSync(rnds8Pool);
+        poolPtr = 0;
+    }
+    return rnds8Pool.slice(poolPtr, (poolPtr += 16));
+}
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    // Note: Be careful editing this code!  It's been tuned for performance
+    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+/**
+ * a easy uuid v4 generator
+ */
+function randomUUID(force) {
+    // node > v14.17
+    if (!force && crypto['randomUUID']) {
+        return crypto['randomUUID']();
+    }
+    const rnds = rng();
+    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return unsafeStringify(rnds);
+}
+exports.randomUUID = randomUUID;
+//# sourceMappingURL=uuid.js.map

package/dist/util/webRouterParam.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractExpressLikeValue = exports.extractKoaLikeValue = void 0;
-const decorator_1 = require("@midwayjs/decorator");
 const index_1 = require("./index");
+const decorator_1 = require("../decorator");
 const extractKoaLikeValue = (key, data, paramType) => {
     if (decorator_1.ALL === data) {
         data = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/core",
-  "version": "3.5.4-beta.2",
+  "version": "3.6.0",
   "description": "midway core",
   "main": "dist/index",
   "typings": "dist/index.d.ts",
@@ -8,7 +8,8 @@
     "build": "tsc",
     "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
     "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit",
-    "link": "npm link"
+    "link": "npm link",
+    "madge": "madge --circular --extensions ts,tsx --exclude 'node_modules|test|dist' src"
   },
   "keywords": [
     "midway",
@@ -21,22 +22,18 @@
   ],
   "license": "MIT",
   "devDependencies": {
-    "@midwayjs/decorator": "^3.4.11",
     "koa": "2.13.4",
-    "midway-test-component": "*",
     "mm": "3.2.0",
     "pg": "8.8.0",
     "raw-body": "2.5.1",
-    "sinon": "14.0.0"
-  },
-  "peerDependencies": {
-    "@midwayjs/decorator": "*"
+    "sinon": "14.0.1"
   },
   "dependencies": {
     "@midwayjs/glob": "^1.0.2",
     "@midwayjs/logger": "^2.15.0",
-    "class-transformer": "^0.5.1",
-    "picomatch": "2.3.1"
+    "class-transformer": "0.5.1",
+    "picomatch": "2.3.1",
+    "reflect-metadata": "0.1.13"
   },
   "author": "Harry Chen <czy88840616@gmail.com>",
   "repository": {
@@ -46,5 +43,5 @@
   "engines": {
     "node": ">=12"
   },
-  "gitHead": "a603d2348d6141f8f723901498f03a162a037708"
+  "gitHead": "22643b0e8519766bb7c68b975930199fc136336e"
 }