✨ 增加 validate schema 功能

Author: zyao89

index.d.ts

@@ -29,6 +29,7 @@ import * as smartMerge from './src/smartMerge';
 import * as virtualFile from './src/virtualFile';
 import * as openBrowser from './src/openBrowser';
 import * as env from './src/env';
+import * as validateSchema from './src/validateSchema';
 
 export {
     moduleAlias,

index.js

@@ -22,6 +22,7 @@ const internal = [
     'virtualFile',
     'openBrowser',
     'Env',
+    'validateSchema',
 ].reduce((obj, key) => {
     obj[key] = `./src/${key}`;
     return obj;

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@micro-app/shared-utils",
-    "version": "0.1.6",
+    "version": "0.1.7",
     "description": "[Shared] shared utilities for micro-app.",
     "main": "index.js",
     "scripts": {
@@ -51,6 +51,8 @@
         "webpack-merge": "^4.2.2"
     },
     "dependencies": {
+        "ajv": "^6.10.2",
+        "ajv-keywords": "^3.4.1",
         "assert": "^2.0.0",
         "chalk": "^2.4.2",
         "cheerio": "^1.0.0-rc.3",

src/Env/index.js

@@ -3,8 +3,8 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
-const LRU = require('./node_modules/lru-cache');
-const semver = require('./node_modules/semver');
+const LRU = require('lru-cache');
+const semver = require('semver');
 
 let _hasYarn;
 const _yarnProjects = new LRU({

src/logger/index.js

@@ -34,26 +34,8 @@ Object.keys(_disp).forEach(key => {
     npmlog.disp[key] = _disp[key];
 });
 
-// reset
-npmlog.addLevel('info', 2000, { fg: 'black', bg: 'blue' }, 'INFO');
-npmlog.addLevel('http', 3000, { fg: 'black', bg: 'cyan' }, 'HTTP');
-npmlog.addLevel('warn', 4000, { fg: 'black', bg: 'yellow' }, 'WARN');
-npmlog.addLevel('error', 5000, { fg: 'black', bg: 'red' }, 'ERR!');
-
 // npmlog.prefixStyle = {};
-const CUSTOM_LEVEL = {
-    success: {
-        level: 3500,
-        fg: 'black',
-        bg: 'green',
-    },
-    noise: {
-        level: 10000,
-        fg: 'black',
-        bg: 'magenta',
-        beep: true,
-    },
-};
+const CUSTOM_LEVEL = require('./levels');
 Object.keys(CUSTOM_LEVEL).forEach(key => {
     const style = CUSTOM_LEVEL[key];
     const disp = style.disp || (key.length > 4 ? key.substr(0, 4) : key).toUpperCase();
@@ -163,7 +145,7 @@ class Logger {
     }
 
     debug() {
-        return this.getMethod('debug')(...arguments);
+        return this.getMethod('verbose')(...arguments);
     }
     warn() {
         return this.getMethod('warn')(...arguments);
@@ -223,7 +205,9 @@ class Logger {
         try {
             assert(...args);
         } catch (err) {
-            this.throw('[assert]', err.message);
+            const e = new Error(err.message);
+            e.stack = e.stack.split(/\r?\n/mg).slice(1).join(os.EOL);
+            this.throw(e, '[assert]', err.message);
         }
     }
 
@@ -234,9 +218,6 @@ class Logger {
                 return logger(this.format[type](...args));
             };
         }
-        if ([ 'debug' ].includes(type)) { // 不再需要 debug
-            type = 'verbose';
-        }
         const logger = this.getNpmlogMethod(type);
         if (typeof logger !== 'function') {
             return logger;
@@ -258,7 +239,7 @@ class Logger {
     }
 
     getStdoutMethod(type) {
-        if ([ 'logo', 'json' ].includes(type)) {
+        if (![ 'info', 'error', 'warn' ].includes(type)) {
             type = 'log';
         }
         return getStdoutMethod(type);

src/logger/levels.js

@@ -0,0 +1,55 @@
+'use strict';
+
+// 自定义等级
+module.exports = {
+    verbose: {
+        level: 1000,
+        fg: 'blue',
+        bg: 'black',
+        disp: 'verb',
+    },
+    info: {
+        level: 2000,
+        fg: 'black',
+        bg: 'blue',
+    },
+    timing: {
+        level: 2500,
+        fg: 'green',
+        bg: 'black',
+        disp: 'timing',
+    },
+    http: {
+        level: 3000,
+        fg: 'black',
+        bg: 'cyan',
+    },
+    notice: {
+        level: 3500,
+        fg: 'blue',
+        bg: 'black',
+        disp: 'notice',
+    },
+    success: {
+        level: 3600,
+        fg: 'black',
+        bg: 'green',
+    },
+    warn: {
+        level: 4000,
+        fg: 'black',
+        bg: 'yellow',
+    },
+    error: {
+        level: 5000,
+        fg: 'black',
+        bg: 'red',
+        disp: 'ERR!',
+    },
+    noise: {
+        level: 10000,
+        fg: 'black',
+        bg: 'magenta',
+        beep: true,
+    },
+};

src/logger/logger.test.js

@@ -49,14 +49,47 @@ describe('Logger', () => {
     it('logger npmlog', () => {
 
         const npmlog = require('npmlog');
-        npmlog.info('abcddd');
+        npmlog.info('abcddd', 'ttt');
 
     });
 
-
     it('logger debug', () => {
         logger.level = 'silly';
-        logger.debug('abc');
+        logger.debug('abcdef');
+    });
+
+    it('logger timing', () => {
+        logger.timing('abcdef');
+    });
+
+    it('logger http', () => {
+        logger.http('abcdef');
+    });
+
+    it('logger notice', () => {
+        logger.notice('abcdef');
+    });
+
+    it('logger noise', () => {
+        logger.noise('abcdef', 'sdd');
+    });
+
+    it('logger logo', () => {
+        logger.logo('abcdef', 'sdd');
+    });
+
+    it('logger json', () => {
+        logger.json('abcdef', 'sdd');
+    });
+
+    it('logger alias', () => {
+        logger.setAlias('cctv', 'logo');
+        logger.cctv('abcdef', 'sdd');
+    });
+
+    it('logger group', () => {
+        const newLogger = logger.newGroup('cctv', 'logo');
+        newLogger.info('abcdef', 'sdd');
     });
 
 });

src/validateSchema/index.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const Ajv = require('ajv');
+const ajv = new Ajv({
+    errorDataPath: 'configuration',
+    allErrors: true,
+    verbose: true,
+});
+require('ajv-keywords')(ajv, [ 'instanceof' ]);
+
+function validateSchema(schema, options) {
+    if (Array.isArray(options)) {
+        const errors = options.map(options => validateObject(schema, options));
+        errors.forEach((list, idx) => {
+            list.forEach(function applyPrefix(err) {
+                err.dataPath = `[${idx}]${err.dataPath}`;
+                if (err.children) {
+                    err.children.forEach(applyPrefix);
+                }
+            });
+        });
+        return errors.reduce((arr, items) => {
+            return arr.concat(items);
+        }, []);
+    }
+    return validateObject(schema, options);
+
+}
+
+function validateObject(schema, options) {
+    const validate = ajv.compile(schema);
+    const valid = validate(options);
+    return valid ? [] : filterErrors(validate.errors);
+}
+
+function filterErrors(errors) {
+    let newErrors = [];
+    errors.forEach(err => {
+        const dataPath = err.dataPath;
+        let children = [];
+        newErrors = newErrors.filter(oldError => {
+            if (oldError.dataPath.includes(dataPath)) {
+                if (oldError.children) {
+                    children = children.concat(oldError.children.slice(0));
+                }
+                oldError.children = undefined;
+                children.push(oldError);
+                return false;
+            }
+            return true;
+        });
+        if (children.length) {
+            err.children = children;
+        }
+        newErrors.push(err);
+    });
+
+    return newErrors;
+}
+
+module.exports = validateSchema;

src/validateSchema/validateSchema.test.js

@@ -0,0 +1,43 @@
+'use strict';
+
+/* global expect */
+
+const validateSchema = require('.');
+
+const schema = {
+    additionalProperties: false,
+    properties: {
+        name: {
+            description: '名称. ( string )',
+            type: 'string',
+        },
+    },
+    type: 'object',
+};
+
+describe('validateSchema', () => {
+
+    it('validate', () => {
+        const result = validateSchema(schema, {
+            name: 'test',
+        });
+        expect(result.length).toEqual(0);
+    });
+
+    it('validate error', () => {
+        const result = validateSchema(schema, {
+            name: 'test',
+            desc: 'bbb',
+        });
+        expect(result.length).toEqual(1);
+    });
+
+    it('validate error2', () => {
+        const result = validateSchema(schema, {
+            name: [ 'test' ],
+            desc: 'bbb',
+        });
+        expect(result.length).toEqual(2);
+    });
+
+});

yarn.lock

@@ -606,6 +606,11 @@ aggregate-error@^3.0.0:
     clean-stack "^2.0.0"
     indent-string "^4.0.0"
 
+ajv-keywords@^3.4.1:
+  version "3.4.1"
+  resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-3.4.1.tgz#ef916e271c64ac12171fd8384eaae6b2345854da"
+  integrity sha512-RO1ibKvd27e6FEShVFfPALuHI3WjSVNeK5FIsmme/LYRNxjKuNj+Dt7bucLa6NdSv3JcVTyMlm9kGR84z1XpaQ==
+
 ajv@^6.10.2, ajv@^6.5.5, ajv@^6.9.1:
   version "6.10.2"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.10.2.tgz#d3cea04d6b017b2894ad69040fec8b623eb4bd52"