not-node 5.0.9 → 5.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "not-node",
-  "version": "5.0.9",
+  "version": "5.0.10",
   "description": "node complimentary part for client side notFramework.",
   "main": "index.js",
   "scripts": {

package/src/auth/rules.js

@@ -6,11 +6,11 @@ function ruleHasRootDirective(rule){
 }
 
 
-function compareWithRoot(rule, admin){
+function compareWithRoot(rule, root){
   if (Object.prototype.hasOwnProperty.call(rule, 'admin')) {
-    return rule.admin && admin;
+    return rule.admin && root;
   } else {
-    return rule.root && admin;
+    return rule.root && root;
   }
 }
 
@@ -51,18 +51,16 @@ function compareAuthStatus(rule, auth){
 
 /**
  *	Check rule against presented credentials
- *	@param	{object}		rule	action rule
- *		{
- *			auth - if user should be authenticated
- *			role - if user shoud have some role
- *			admin - if user should be super user
- *		}
- *	@param {Boolean}		auth	user state of auth
- *	@param {String|Array}	role	user state of role
- *	@param {Boolean}		admin	user state of admin
- *	@return {boolean}		pass or not
+ *	@param	{object}		        rule	      action rule
+ *  @param	{boolean}		        rule.auth   if user should be authenticated
+ *  @param	{Array<String>}		  rule.role   if user shoud have some role
+ *  @param	{boolean}		        rule.root   if user should be super user
+ *	@param  {Boolean}		        auth	      user state of auth
+ *	@param  {String|Array}	    role	      user state of role
+ *	@param  {Boolean}		        root        user state of root
+ *	@return {boolean}		        pass or not
  */
-function checkCredentials(rule, auth, role, admin) {
+function checkCredentials(rule, auth, role, root) {
   //no rule - no access
   if (typeof rule === 'undefined' || rule === null) {
     return false;
@@ -72,7 +70,7 @@ function checkCredentials(rule, auth, role, admin) {
     //start comparing from top tier flags
     //if we have root/admin(obsolete) field field in rule compare only it
     if (ruleHasRootDirective(rule)) {
-      return compareWithRoot(rule, admin);
+      return compareWithRoot(rule, root);
     } else {
       //if we have roles in rule, then using role based aproach
       if (Object.prototype.hasOwnProperty.call(rule, 'role')) {

package/src/core/locales/en.json

@@ -1,4 +1,6 @@
 {
+  "booleans_false": "True",
+  "booleans_true": "False",
   "form_validation_error": "Form validation error",
   "field_active_label": "Active",
   "field_codeName_label": "Code name",

package/src/core/locales/ru.json

@@ -1,4 +1,6 @@
 {
+  "booleans_false": "Да",
+  "booleans_true": "Нет",
   "form_validation_error": "Форма заполнена с ошибками",
   "field_active_label": "Активна",
   "field_codeName_label": "Псевдоним",

package/src/model/increment.js

@@ -62,6 +62,19 @@ function secureUpdate(thisModel, which, cmd, opts){
 
 module.exports.secureUpdate = secureUpdate;
 
+function updateResponseSuccess(res){
+  if(res){
+    const responseList = Object.keys(res);
+    if(responseList.includes('ok')){
+      return (res.ok === 1 && res.n === 1);
+    }else{
+      return (res.matchedCount === 1 && res.modifiedCount === 1);
+    }
+  }else{
+    return false;
+  }
+}
+
 /**
 * Generate new ID for current model and filterFields
 **/
@@ -99,8 +112,8 @@ function newGetNext() {
         new: true,
         upsert: true
       };
-    let res = await secureUpdate(thisModel, which, cmd, opts);
-    if(res.ok === 1 && res.n === 1){
+    const res = await secureUpdate(thisModel, which, cmd, opts);
+    if(updateResponseSuccess(res)){
       const doc = await thisModel.findOne({id});
       return doc.seq;
     }else{
@@ -133,7 +146,7 @@ function newRebase(){
       };
     //updating
     let res = await secureUpdate(thisModel, which, cmd, opts);
-    if(res.ok === 1 && res.n === 1){
+    if(updateResponseSuccess(res)){
       return ID;
     }else{
       throw new Error('ID generator rebase failed');

package/src/fields/.old.js

@@ -1,193 +0,0 @@
-const clone = require('rfdc')();
-const fs = require('fs');
-const path = require('path');
-const {objHas, tryFile} = require('../common');
-
-const DEFAULT_FIELD_REGISTRATION_RULES = {
-  overwrite: false,
-  compose: true
-};
-
-const FIELDS = {};
-
-module.exports.importFromDir = (srcDir, {overwrite = false, compose = true} = DEFAULT_FIELD_REGISTRATION_RULES)=>{
-  fs.readdirSync(srcDir).forEach((file) => {
-    let fromPath = path.join(srcDir, file);
-    if (!tryFile(fromPath)) { return; }
-    const parts = path.parse(fromPath);
-    registerField(parts.name, require(fromPath), {overwrite, compose});
-  });
-};
-
-
-const registerField = module.exports.registerField = (name, value, {overwrite = false, compose = true} = DEFAULT_FIELD_REGISTRATION_RULES)=>{
-  if(objHas(FIELDS, name)){
-    if(overwrite){
-      FIELDS[name] = value;
-    }else if(compose){
-      Object.assign(FIELDS[name], value);
-    }
-  }else{
-    FIELDS[name] = value;
-  }
-};
-
-
-module.exports.registerFields = (fields, {overwrite = false, compose = true})=>{
-  for(let t in fields){
-    module.exports.registerField(t, fields[t], {overwrite, compose});
-  }
-};
-
-/**
-list = [
-  'title', //for standart only name
-  ['titleNonStandart', {component: 'UITextforBlind'}] //arrays of [name, mutation]
-  ['someID', {}, 'ID'],  //copy of standart ID field under name as someID
-]
-*/
-module.exports.initFields = (list, type = 'ui') => {
-  let fields = {};
-  list.forEach((field) => {
-    let res = module.exports.initField(field, false, type);
-    fields[res[0]] = res[1];
-  });
-  return fields;
-};
-
-
-/**
-* Retrieves field information
-* there are few signatures of this function
-* (field:string, resultOnly:boolean = true, type:string = 'ui')=> Object | [string, Object]
-* (field:Array<string, Object>, resultOnly:boolean = true, type:string = 'ui')=> Object | [string, Object]
-* @param {(string|Array)} field   field to retrieve from store and init
-                                  field: string - just name of the field
-                                  field: Array - [destinationField:string, mutation: Object, sourceField:string]
-                                  field: Array - [sourceField:string, mutation: Object]
-                                                sourceField - standart field to extend
-                                                mutation - to extend by
-                                                destinationField - name of resulting field,
-                                                if no dest then src will be used
-* @param {boolean}  resultOnly    return only result, if false then returns [name, value]
-* @param {string}   type          type of field information
-**/
-module.exports.initField = (field, resultOnly = true, type = 'ui') => {
-  let srcName, destName, mutation = {};
-  if (Array.isArray(field)) {
-    destName = srcName = field[0];
-    mutation = field[1];
-    if (field.length === 3) {
-      srcName = field[2];
-    }
-  } else {
-    destName = srcName = field;
-  }
-  let proto = findFieldDescription(srcName, type);
-  let result = Object.assign({}, clone(proto), mutation);
-  if (resultOnly) {
-    return result;
-  } else {
-    return [destName, result];
-  }
-};
-
-function findFieldDescription(name, type){
-  return (objHas(FIELDS, name) && objHas(FIELDS[name], type)) ? FIELDS[name][type]:{};
-}
-
-
-
-/**
-* 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;
-    }
-  }
-  return false;
-}
-module.exports.getMutationForField = getMutationForField;
-
-/**
-* Takes in mongoose model schema, scans for fields names and creates list of
-* field's names to initialize from LIB, if in supplied rawMutationsList, exists
-* mutation for a field in list, field name in list will be replaced by a
-* mutation description
-* @param {Object} schema            mongoose model schema
-* @param {Array}  rawMutationsList  list of mutations [src, mutation]/[dst,mutation,src]
-* @returns {Object}                 initialized ui descriptions of fields for schema
-**/
-module.exports.fromSchema = (schema, rawMutationsList = []) => {
-  let
-    //shallow copy of array
-    mutationsList = [...rawMutationsList],
-    list = [];
-  if (schema && Object.keys(schema).length > 0) {
-    let rawKeys = Object.keys(schema);
-    rawKeys.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.initFields(list);
-  }else{
-    return {};
-  }
-};
-
-module.exports.LIB = FIELDS;
-
-
-module.exports.initFieldsFromApp = (list, type = 'ui', app) => {
-  let fields = {};
-  list.forEach((field) => {
-    let res = module.exports.initFieldFromApp(field, false, type, app);
-    fields[res[0]] = res[1];
-  });
-  return fields;
-};
-
-
-module.exports.initFieldFromApp = (field, resultOnly = true, type = 'ui', app) => {
-  let srcName, destName, mutation = {};
-  if (Array.isArray(field)) {
-    destName = srcName = field[0];
-    mutation = field[1];
-    if (field.length === 3) {
-      srcName = field[2];
-    }
-  } else {
-    destName = srcName = field;
-  }
-  let proto = findFieldDescriptionFromApp(srcName, type, app);
-  if(proto){
-    let result = Object.assign({}, clone(proto), mutation);
-    if (resultOnly) {
-      return result;
-    } else {
-      return [destName, result];
-    }
-  }else{
-    throw new Error(`Field (${srcName}) definition is not found`);
-  }
-};
-
-function findFieldDescriptionFromApp(name, type, app){
-  const field = app.getField(name);
-  if(field && objHas(field, type)){
-    return field[type];
-  }else{
-    return null;
-  }
-}

package/src/init/layers/fields.js

@@ -1,7 +0,0 @@
-module.exports = class InitFields{
-  async run({master/*, config*/}){
-    //compress output
-    const compression = require('compression');
-    master.getServer().use(compression());
-  }
-};