not-node 5.0.19 → 5.1.0

package/src/env.js

@@ -1,31 +1,31 @@
-const {objHas} = require('./common');
+const { objHas } = require("./common");
 
 const ENVS = {
-  process: process.env.NODE_ENV || 'development'
+    process: process.env.NODE_ENV || "development",
 };
 
 module.exports = class notEnv {
-  /**
-   *  Returns application environment variable
-   *  @param   {string}      key  name of var
-   *  @return {object|undefined}    value or undefined
-   */
-  static getEnv(key) {
-    if (objHas(ENVS,key)) {
-      return ENVS[key];
-    } else {
-      return undefined;
+    /**
+     *  Returns application environment variable
+     *  @param   {string}      key  name of var
+     *  @return {object|undefined}    value or undefined
+     */
+    static getEnv(key) {
+        if (objHas(ENVS, key)) {
+            return ENVS[key];
+        } else {
+            return undefined;
+        }
     }
-  }
 
-  /**
-   *  Setting application environment variable
-   *  @param   {string}      key  name of var
-   *  @param   {object}      val  value
-   *  @return {notDomain}      chainable
-   */
-  static setEnv(key, val) {
-    ENVS[key] = val;
-    return notEnv;
-  }
+    /**
+     *  Setting application environment variable
+     *  @param   {string}      key  name of var
+     *  @param   {object}      val  value
+     *  @return {notDomain}      chainable
+     */
+    static setEnv(key, val) {
+        ENVS[key] = val;
+        return notEnv;
+    }
 };

package/src/error.js

@@ -1,22 +1,19 @@
 /** @module not-node/Error */
 
-const {objHas} = require('./common');
-const
-  util = require('util'),
-  http = require('http');
+const { objHas } = require("./common");
+const util = require("util"),
+    http = require("http");
 
 function HttpError(status, message) {
-  Error.apply(this, arguments);
-  Error.captureStackTrace(this, HttpError);
-  this.status = status;
-  this.message = message || http.STATUS_CODES[status] || 'Error';
+    Error.apply(this, arguments);
+    Error.captureStackTrace(this, HttpError);
+    this.status = status;
+    this.message = message || http.STATUS_CODES[status] || "Error";
 }
 
 util.inherits(HttpError, Error);
 
-
-HttpError.prototype.name = 'HttpError';
-
+HttpError.prototype.name = "HttpError";
 
 module.exports.Http = HttpError;
 
@@ -28,17 +25,17 @@ module.exports.Http = HttpError;
  *  @return {object}  modified errors
  */
 
-module.exports.addError = function(errors, field, error) {
-  if (!errors) {
-    errors = {};
-  }
-  if (!objHas(errors,field)) {
-    errors[field] = [];
-  } else {
-    if (!Array.isArray(errors[field])) {
-      errors[field] = [errors[field]];
+module.exports.addError = function (errors, field, error) {
+    if (!errors) {
+        errors = {};
+    }
+    if (!objHas(errors, field)) {
+        errors[field] = [];
+    } else {
+        if (!Array.isArray(errors[field])) {
+            errors[field] = [errors[field]];
+        }
     }
-  }
-  errors[field].push(error);
-  return errors;
+    errors[field].push(error);
+    return errors;
 };

package/src/exceptions/db.js

@@ -0,0 +1,23 @@
+const { notRequestError } = require("not-error");
+
+//delete wasnt successful, or error, or count of deleted documents dont match requested
+class DBExceptionDeleteWasNotSuccessful extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super("DB Delete Was Not Successful", { code: 505, ...params }, cause);
+    }
+}
+module.exports.DBExceptionDeleteWasNotSuccessful =
+    DBExceptionDeleteWasNotSuccessful;
+
+//delete wasnt successful, bc document is owned by another user
+class DBExceptionDocumentIsNotOwnerByActiveUser extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super(
+            "DB Only Owners Could Delete their documents",
+            { code: 403, ...params },
+            cause
+        );
+    }
+}
+module.exports.DBExceptionDocumentIsNotOwnerByActiveUser =
+    DBExceptionDocumentIsNotOwnerByActiveUser;

package/src/exceptions/http.js

@@ -0,0 +1,43 @@
+const { notRequestError } = require("not-error");
+
+//https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses
+
+//form of request is not valid
+class HttpExceptionBadRequest extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super("Bad Request", { code: 400, ...params }, cause);
+    }
+}
+module.exports.HttpExceptionBadRequest = HttpExceptionBadRequest;
+
+//user is not authenticated
+class HttpExceptionUnauthorized extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super("Unauthorized", { code: 401, ...params }, cause);
+    }
+}
+module.exports.HttpExceptionUnauthorized = HttpExceptionUnauthorized;
+
+//user is too poor to go there
+class HttpExceptionPaymentRequired extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super("Payment Required", { code: 402, ...params }, cause);
+    }
+}
+module.exports.HttpExceptionPaymentRequired = HttpExceptionPaymentRequired;
+
+//user identity is known, but he has no right to go there
+class HttpExceptionForbidden extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super("Forbidden", { code: 403, ...params }, cause);
+    }
+}
+module.exports.HttpExceptionForbidden = HttpExceptionForbidden;
+
+//requested address is not exists
+class HttpExceptionNotFound extends notRequestError {
+    constructor({ params = {}, cause = null }) {
+        super("Not Found", { code: 404, ...params }, cause);
+    }
+}
+module.exports.HttpExceptionNotFound = HttpExceptionNotFound;

package/src/fields/index.js

@@ -1,22 +1,31 @@
-const clone = require('rfdc')();
-const notPath = require('not-path');
-const {error} = require('not-log')(module, 'init//fields');
-const {notError} = require('not-error');
+const clone = require("rfdc")();
+const notPath = require("not-path");
+const { error } = require("not-log")(module, "init//fields");
 
-const {
-  objHas,
-} = require('../common');
+const { objHas } = require("../common");
 
-const DEFAULT_TYPE = 'ui';
-const DEFAULT_FROM = ':FIELDS';
-const DEFAULT_TO = ':thisSchema';
+const DEFAULT_TYPE = "ui";
+const DEFAULT_FROM = ":FIELDS";
+const DEFAULT_TO = ":thisSchema";
 
-module.exports.initFileSchemaFromFields = ({app, mod, type = DEFAULT_TYPE, from = DEFAULT_FROM, to = DEFAULT_TO, moduleName = ''})=>{
-  const FIELDS = notPath.get(from, mod);
-  if(FIELDS && Array.isArray(FIELDS)){
-    const schema = module.exports.createSchemaFromFields(app, FIELDS, type, moduleName);
-    notPath.set(to, mod, schema);
-  }
+module.exports.initFileSchemaFromFields = ({
+    app,
+    mod,
+    type = DEFAULT_TYPE,
+    from = DEFAULT_FROM,
+    to = DEFAULT_TO,
+    moduleName = "",
+}) => {
+    const FIELDS = notPath.get(from, mod);
+    if (FIELDS && Array.isArray(FIELDS)) {
+        const schema = module.exports.createSchemaFromFields(
+            app,
+            FIELDS,
+            type,
+            moduleName
+        );
+        notPath.set(to, mod, schema);
+    }
 };
 
 /**
@@ -26,131 +35,140 @@ fields = [
   ['someID', {}, 'ID'],  //copy of standart ID field under name as someID
 ]
 **/
-module.exports.createSchemaFromFields = (app, fields, type = 'ui', moduleName) => {
-  let schema = {};
-  fields.forEach((field) => {
-    let [schemaFieldName, schemaFieldValue] = module.exports.initSchemaField(app, field, false, type, moduleName);
-    schema[schemaFieldName] = schemaFieldValue;
-  });
-  return schema;
+module.exports.createSchemaFromFields = (
+    app,
+    fields,
+    type = "ui",
+    moduleName
+) => {
+    let schema = {};
+    fields.forEach((field) => {
+        let [schemaFieldName, schemaFieldValue] =
+            module.exports.initSchemaField(app, field, false, type, moduleName);
+        schema[schemaFieldName] = schemaFieldValue;
+    });
+    return schema;
 };
 
-
-module.exports.initSchemaField = (app, field, resultOnly = true, type = 'ui', moduleName) => {
-  //log(field);
-  let {
-    srcName,
-    destName,
-    mutation
-  } = parseFieldDescription(field);
-  let proto = findFieldPrototype(app, srcName, type);
-  if(!proto){
-    error(`field ${moduleName}//${destName} prototype ${srcName} of ${type} type is not found`);
-  }
-  let schemaFieldValue = Object.assign({}, clone(proto), mutation);
-  if (resultOnly) {
-    return schemaFieldValue;
-  } else {
-    return [destName, schemaFieldValue];
-  }
+module.exports.initSchemaField = (
+    app,
+    field,
+    resultOnly = true,
+    type = "ui",
+    moduleName
+) => {
+    //log(field);
+    let { srcName, destName, mutation } = parseFieldDescription(field);
+    let proto = findFieldPrototype(app, srcName, type);
+    if (!proto) {
+        error(
+            `field ${moduleName}//${destName} prototype ${srcName} of ${type} type is not found`
+        );
+    }
+    let schemaFieldValue = Object.assign({}, clone(proto), mutation);
+    if (resultOnly) {
+        return schemaFieldValue;
+    } else {
+        return [destName, schemaFieldValue];
+    }
 };
 
 /**
-* field form
-* 'destFieldNameSameAsSourceFieldName' - form 1
-* ['destFieldName', {full: true, field: 'content'}] - form 2
-* ['destFieldName', 'srcFieldName'] //field alias, form 3
-* ['destFieldName', {mutation: 'content'}, 'srcFieldName']// - form 4
-**/
+ * field form
+ * 'destFieldNameSameAsSourceFieldName' - form 1
+ * ['destFieldName', {full: true, field: 'content'}] - form 2
+ * ['destFieldName', 'srcFieldName'] //field alias, form 3
+ * ['destFieldName', {mutation: 'content'}, 'srcFieldName']// - form 4
+ **/
 const parseFieldDescription = (field) => {
-  let srcName,
-    destName,
-    mutation = {};
-  if (Array.isArray(field)) {
-    destName = srcName = field[0];
-    if(field.length === 2){
-      if(typeof field[1] === 'string'){
-        srcName = field[1]; //form 3
-      }else{
-        mutation = field[1]; //form 2
-      }
-    }else if (field.length === 3) { //form 4
-      mutation = field[1];
-      srcName = field[2];
+    let srcName,
+        destName,
+        mutation = {};
+    if (Array.isArray(field)) {
+        destName = srcName = field[0];
+        if (field.length === 2) {
+            if (typeof field[1] === "string") {
+                srcName = field[1]; //form 3
+            } else {
+                mutation = field[1]; //form 2
+            }
+        } else if (field.length === 3) {
+            //form 4
+            mutation = field[1];
+            srcName = field[2];
+        }
+    } else {
+        destName = srcName = field; //form 1
     }
-  } else {
-    destName = srcName = field; //form 1
-  }
-  return {
-    srcName,
-    destName,
-    mutation
-  };
+    return {
+        srcName,
+        destName,
+        mutation,
+    };
 };
 
 const findFieldPrototype = (app, name, type) => {
-  const fieldPrototype = app.getField(name);
-  if(fieldPrototype && objHas(fieldPrototype, type)){
-    return fieldPrototype[type];
-  }else{
-    return null;
-  }
+    const fieldPrototype = app.getField(name);
+    if (fieldPrototype && objHas(fieldPrototype, type)) {
+        return fieldPrototype[type];
+    } else {
+        return null;
+    }
 };
 
 /**
-* Creates fields UI representation schema from list of fields in DB model
-* and library of fields
-* @param {object} app     notApplication instance
-* @param {object} schema  model db schema
-* @param {Array<string|Array>} rawMutationsList     fields mutations, for little tuning
-* @param {Array<string>} privateFields     fields to omit from result
-* @param {string} moduleName     for detailed reports on issues, in which module and what field is faulty
-* @returns {object}       resulting UI rendering schema for fields
-**/
+ * Creates fields UI representation schema from list of fields in DB model
+ * and library of fields
+ * @param {object} app     notApplication instance
+ * @param {object} schema  model db schema
+ * @param {Array<string|Array>} rawMutationsList     fields mutations, for little tuning
+ * @param {Array<string>} privateFields     fields to omit from result
+ * @param {string} moduleName     for detailed reports on issues, in which module and what field is faulty
+ * @returns {object}       resulting UI rendering schema for fields
+ **/
 
 module.exports.initManifestFields = (
-  app,                    //notApplication
-  schema,                 //schema of model
-  rawMutationsList = [],  //fields mutations
-  privateFields = [],     //fields to omit
-  moduleName              //module name for reporting
+    app, //notApplication
+    schema, //schema of model
+    rawMutationsList = [], //fields mutations
+    privateFields = [], //fields to omit
+    moduleName //module name for reporting
 ) => {
-  let
-    //shallow copy of array
-    mutationsList = [...rawMutationsList],
-    list = [];
-  if (schema && Object.keys(schema).length > 0) {
-    let rawKeys = Object.keys(schema);
-    rawKeys
-      .filter((key) => !privateFields.includes(key))
-      .forEach((key) => {
-        let mutation = getMutationForField(key, mutationsList);
-        if (mutation) {
-          list.push(mutation);
-          mutationsList.splice(mutationsList.indexOf(mutation), 1);
-        } else {
-          list.push(key);
-        }
-      });
-    list.push(...mutationsList);
-    return module.exports.createSchemaFromFields(app, list, 'ui', moduleName);
-  }else{
-    return {};
-  }
+    let //shallow copy of array
+        mutationsList = [...rawMutationsList],
+        list = [];
+    if (schema && Object.keys(schema).length > 0) {
+        let rawKeys = Object.keys(schema);
+        rawKeys
+            .filter((key) => !privateFields.includes(key))
+            .forEach((key) => {
+                let mutation = getMutationForField(key, mutationsList);
+                if (mutation) {
+                    list.push(mutation);
+                    mutationsList.splice(mutationsList.indexOf(mutation), 1);
+                } else {
+                    list.push(key);
+                }
+            });
+        list.push(...mutationsList);
+    } else {
+        list = mutationsList;
+    }
+    return module.exports.createSchemaFromFields(app, list, "ui", moduleName);
 };
 
 /**
-* Returns mutation tuple for a field or false
-* @param {string} name  field name
-* @param {Array} list  fields description lists
-* @return {boolean|item}
-*/
+ * Returns mutation tuple for a field or false
+ * @param {string} name  field name
+ * @param {Array} list  fields description lists
+ * @return {boolean|item}
+ */
 function getMutationForField(name, list) {
-  for(let item of list){
-    if (Array.isArray(item) && item[0] === name) {
-      return item;
+    for (let item of list) {
+        if (Array.isArray(item) && item[0] === name) {
+            return item;
+        }
     }
-  }
-  return false;
+    return false;
 }
 module.exports.getMutationForField = getMutationForField;

package/src/form/fabric.js

@@ -1,28 +1,23 @@
-const Form = require('./form');
+const Form = require("./form");
 
 module.exports = class FormFabric {
-  static create({
-    FIELDS,
-    MODULE_NAME,
-    FORM_NAME,
-    extractor
-  }) {
-    return class extends Form {
-      constructor() {
-        super({
-          FIELDS,
-          FORM_NAME: `${MODULE_NAME}:${FORM_NAME}`
-        });
-      }
+    static create({ FIELDS, MODULE_NAME, FORM_NAME, extractor }) {
+        return class extends Form {
+            constructor() {
+                super({
+                    FIELDS,
+                    FORM_NAME: `${MODULE_NAME}:${FORM_NAME}`,
+                });
+            }
 
-      /**
-       * Extracts data
-       * @param {ExpressRequest} req expressjs request object
-       * @return {Object}        forma data
-       **/
-      extract(req) {
-        return extractor(req);
-      }
-    };
-  }
+            /**
+             * Extracts data
+             * @param {ExpressRequest} req expressjs request object
+             * @return {Object}        forma data
+             **/
+            extract(req) {
+                return extractor(req);
+            }
+        };
+    }
 };