Initial commit

manager/src/backend/lib/error.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const _    = require('lodash');
+const util = require('util');
+
+module.exports = {
+
+    ItemNotFoundError: function (id, previous) {
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.previous = previous;
+        this.message = 'Item Not Found - ' + id;
+        this.public = true;
+        this.status = 404;
+    },
+
+    InternalError: function (message, previous) {
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.previous = previous;
+        this.message = message;
+        this.status = 500;
+        this.public = false;
+    },
+
+    InternalValidationError: function (message, previous) {
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.previous = previous;
+        this.message = message;
+        this.status = 400;
+        this.public = false;
+    },
+
+    ConfigurationError: function (message, previous) {
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.previous = previous;
+        this.message = message;
+        this.status = 400;
+        this.public = true;
+    },
+
+    ValidationError: function (message, previous) {
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.previous = previous;
+        this.message = message;
+        this.public = true;
+        this.status = 400;
+    }
+};
+
+_.forEach(module.exports, function (error) {
+    util.inherits(error, Error);
+});

manager/src/backend/lib/utils.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const exec = require('child_process').exec;
+
+module.exports = {
+
+    /**
+     * @param   {String} cmd
+     * @returns {Promise}
+     */
+    exec: function (cmd) {
+        return new Promise((resolve, reject) => {
+            exec(cmd, function (err, stdout, stderr) {
+                if (err && typeof err === 'object') {
+                    reject(err);
+                } else {
+                    resolve(stdout.trim());
+                }
+            });
+        });
+    }
+};

manager/src/backend/lib/validator/api.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const error  = require('../error');
+const path   = require('path');
+const parser = require('json-schema-ref-parser');
+
+const ajv = require('ajv')({
+    verbose:        true,
+    validateSchema: true,
+    allErrors:      false,
+    format:         'full',  // strict regexes for format checks
+    coerceTypes:    true
+});
+
+/**
+ * @param {Object} schema
+ * @param {Object} payload
+ * @returns {Promise}
+ */
+function apiValidator (schema, payload/*, description*/) {
+    return new Promise(function Promise_apiValidator (resolve, reject) {
+        if (typeof payload === 'undefined') {
+            reject(new error.ValidationError('Payload is undefined'));
+        }
+
+        let validate = ajv.compile(schema);
+        let valid    = validate(payload);
+
+        if (valid && !validate.errors) {
+            resolve(payload);
+        } else {
+            let message = ajv.errorsText(validate.errors);
+            //debug(validate.errors);
+
+            let err   = new error.ValidationError(message);
+            err.debug = [validate.errors, payload];
+            reject(err);
+        }
+    });
+}
+
+apiValidator.loadSchemas = parser
+    .dereference(path.resolve('src/backend/schema/index.json'))
+    .then((schema) => {
+        ajv.addSchema(schema);
+        return schema;
+    });
+
+module.exports = apiValidator;

manager/src/backend/lib/validator/index.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const _           = require('lodash');
+const error       = require('../error');
+const definitions = require('../../schema/definitions.json');
+
+RegExp.prototype.toJSON = RegExp.prototype.toString;
+
+const ajv = require('ajv')({
+    verbose:     true, //process.env.NODE_ENV === 'development',
+    allErrors:   true,
+    format:      'full',  // strict regexes for format checks
+    coerceTypes: true,
+    schemas:     [
+        definitions
+    ]
+});
+
+/**
+ *
+ * @param {Object} schema
+ * @param {Object} payload
+ * @returns {Promise}
+ */
+function validator (schema, payload) {
+    return new Promise(function (resolve, reject) {
+        if (!payload) {
+            reject(new error.InternalValidationError('Payload is falsy'));
+        } else {
+            try {
+                let validate = ajv.compile(schema);
+                let valid    = validate(payload);
+                if (valid && !validate.errors) {
+                    resolve(_.cloneDeep(payload));
+                } else {
+                    //debug('Validation failed:', schema, payload);
+                    let message = ajv.errorsText(validate.errors);
+                    reject(new error.InternalValidationError(message));
+                }
+            } catch (err) {
+                reject(err);
+            }
+        }
+    });
+}
+
+module.exports = validator;