not-node 5.0.22 → 5.1.0

package/.eslintrc.json

@@ -28,7 +28,7 @@
     "node/prefer-global/url-search-params": ["error", "always"],
     "node/prefer-global/url": ["error", "always"],
     "node/no-unpublished-require": "warn",
-    "indent": ["error", 2],
+    "indent": ["error", 4],
     "linebreak-style": [
       "error",
       "unix"

package/bin/not-deploy.js

@@ -0,0 +1,52 @@
+/**
+
+#!/bin/bash
+cwd
+echo 'deploying to production'
+cd reporter 
+npm run production 
+cd ../
+echo 'syncing data'
+rsync -av --progress --exclude-from='./deploy/.exclude' reporter cypher@appmon.ru:/var/server/appmon.ru/ 
+rsync -av --progress deploy/production.json cypher@appmon.ru:/var/server/appmon.ru/deploy/production.json 
+ssh cypher@appmon.ru "cd /var/server/appmon.ru/reporter && npm i"
+ssh cypher@appmon.ru "cd /var/server/appmon.ru && pm2 startOrRestart deploy/production.json"
+exit 0;
+
+read config
+cycle through remote locations
+deploy as selected method in config say
+
+{
+    deploy:{
+        stage:{},
+        production:{
+            src:{
+                type: "fs",                         //fs, git
+                location: "/var/work/project",      //path to dir or url of repo
+                include: [],                        //optional, files to not copy
+                exclude: [],                        //optional, files to not copy
+                //will be executed localy
+                before-setup:     "",               //optional, shell cmd
+                after-setup:      "",               //optional, shell cmd
+                before:     "",                     //optional, shell cmd
+                after:      "",                     //optional, shell cmd
+                secret:     "./production.env"      //optional
+            },
+            dest:{
+                username:  "deploy-master-3000",  //
+                server: ["username@server", "10.0.1.12"],        //
+                path: "/path/on/server",            //
+                //will be executed on remote side
+                before-setup:     "",               //optional, shell cmd
+                after-setup:      "",               //optional, shell cmd
+                before:     "",                     //optional, shell cmd
+                after:      "",                     //optional, shell cmd
+                secret: "/path/on/server/where/secret_should_be_copied" //optional
+            }
+        }
+    }
+}
+
+
+**/

package/index.js

@@ -1,41 +1,43 @@
 /**
-* @module not-node
-*/
+ * @module not-node
+ */
 
-module.exports.Env = require('./src/env.js');
+module.exports.Env = require("./src/env.js");
 /** Error module
  * @type {not-node/Error}
  */
-module.exports.Error = require('./src/error.js');
+module.exports.Error = require("./src/error.js");
 /** Authentication module */
-module.exports.Auth = require('./src/auth');
+module.exports.Auth = require("./src/auth");
 /** Manifest infrastructure */
-module.exports.Manifest = require('./src/manifest/manifest');
+module.exports.Manifest = require("./src/manifest/manifest");
 /** Web Application */
-module.exports.notApp = require('./src/app');
+module.exports.notApp = require("./src/app");
 /** General Application */
-module.exports.notDomain = require('./src/domain');
+module.exports.notDomain = require("./src/domain");
 /** Mongoose Documents versioning */
-module.exports.Versioning = require('./src/model/versioning');
+module.exports.Versioning = require("./src/model/versioning");
 /** Mongoose Model autoincrement field */
-module.exports.Increment = require('./src/model/increment');
+module.exports.Increment = require("./src/model/increment");
 /** Mongoose Model prototype */
-module.exports.Proto = require('./src/model/proto');
+module.exports.Proto = require("./src/model/proto");
 /** Mongoose Model additional features enricher */
-module.exports.Enrich = require('./src/model/enrich');
+module.exports.Enrich = require("./src/model/enrich");
 /** Mongoose Documents routine operation*/
-module.exports.Routine = require('./src/model/routine');
+module.exports.Routine = require("./src/model/routine");
 /** Common functions */
-module.exports.Common = require('./src/common');
+module.exports.Common = require("./src/common");
 /** Fields library manager */
-module.exports.Fields = require('./src/fields');
+module.exports.Fields = require("./src/fields");
 /** Form validation template **/
-module.exports.Form = require('./src/form').Form;
+module.exports.Form = require("./src/form").Form;
 /** Form validation template fabric **/
-module.exports.FormFabric = require('./src/form').FormFabric;
+module.exports.FormFabric = require("./src/form").FormFabric;
 /** Application initialization procedures */
-module.exports.Init = require('./src/init').Init;
+module.exports.Init = require("./src/init").Init;
 /** Application object */
 module.exports.Application = null;
 /** Application bootstrap helpers */
-module.exports.Bootstrap = require('./src/bootstrap');
+module.exports.Bootstrap = require("./src/bootstrap");
+/** Application generic helpers */
+module.exports.Generic = require("./src/generic/index.js");

package/package.json

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

package/src/app.js

@@ -1,8 +1,8 @@
-const Auth = require('./auth');
-const notDomain = require('./domain');
-const merge = require('deepmerge');
-const parent = require('../index.js');
-const {objHas} = require('./common');
+const Auth = require("./auth");
+const notDomain = require("./domain");
+const merge = require("deepmerge");
+const parent = require("../index.js");
+const { objHas } = require("./common");
 
 /**
  *	Application
@@ -31,65 +31,68 @@ const {objHas} = require('./common');
  *		.expose(ExpressApp);
  **/
 class notApp extends notDomain {
-  constructor(options) {
-    super(options);
-    parent.Application = this;
-    parent.getModel = this.getModel.bind(this);
-    parent.getLogic = this.getLogic.bind(this);
-    parent.getRoute = this.getRoute.bind(this);
-    parent.getModelFile = this.getModelFile.bind(this);
-    parent.getModelSchema = this.getModelSchema.bind(this);
-    parent.getLogicFile = this.getLogicFile.bind(this);
-    parent.execInModules = this.execInModules.bind(this);
-    return this;
-  }
-
-  /**
-   *	Returns application manifest, by ExpressRequest
-   *	@params		{object}	req 			Express request object
-   *	@return 	{object}	manifest
-   **/
-  getManifest(req) {
-    const creds = Auth.extractAuthData(req);
-    return this.collectManifest(creds);
-  }
+    constructor(options) {
+        super(options);
+        parent.Application = this;
+        parent.getModel = this.getModel.bind(this);
+        parent.getLogic = this.getLogic.bind(this);
+        parent.getRoute = this.getRoute.bind(this);
+        parent.getModelFile = this.getModelFile.bind(this);
+        parent.getModelSchema = this.getModelSchema.bind(this);
+        parent.getLogicFile = this.getLogicFile.bind(this);
+        parent.execInModules = this.execInModules.bind(this);
+        return this;
+    }
 
-  /**
-   *	Returns application manifest, by user credentials object
-   *	@params		{object}	creds 		not-node Auth.extractAuthData result
-   *	@return 	{object}	manifest
-   **/
-  collectManifest(creds){
-    let manifest = {};
-    for (let modName of this.getModulesNames()) {
-      manifest = merge(manifest, this.getModule(modName).getManifest(creds));
+    /**
+     *	Returns application manifest, by ExpressRequest
+     *	@params		{object}	req 			Express request object
+     *	@return 	{object}	manifest
+     **/
+    getManifest(req) {
+        const creds = Auth.extractAuthData(req);
+        return this.collectManifest(creds);
     }
-    return manifest;
-  }
 
-  /**
-   *	Exposes routes to ExpressJS application
-   *	@param {object} 	app	ExpressJS application instance
-   **/
-  expose(app) {
-    this.forEachMod((modName, mod)=>{
-      if (typeof mod.expose === 'function') {
-        mod.expose(app, modName);
-      }
-    });
-  }
+    /**
+     *	Returns application manifest, by user credentials object
+     *	@params		{object}	creds 		not-node Auth.extractAuthData result
+     *	@return 	{object}	manifest
+     **/
+    collectManifest(creds) {
+        let manifest = {};
+        for (let modName of this.getModulesNames()) {
+            manifest = merge(
+                manifest,
+                this.getModule(modName).getManifest(creds)
+            );
+        }
+        return manifest;
+    }
 
-  getActionManifestForUser(model, action, user) {
-    const manifest = this.collectManifest(user);
-    if(Object.keys(manifest).includes(model)
-      && objHas(manifest[model], 'actions')
-      && objHas(manifest[model].actions, action)
-    ){
-      return manifest[model].actions[action];
+    /**
+     *	Exposes routes to ExpressJS application
+     *	@param {object} 	app	ExpressJS application instance
+     **/
+    expose(app) {
+        this.forEachMod((modName, mod) => {
+            if (typeof mod.expose === "function") {
+                mod.expose(app, modName);
+            }
+        });
     }
-    return false;
-  }
 
+    getActionManifestForUser(model, action, user) {
+        const manifest = this.collectManifest(user);
+        if (
+            Object.keys(manifest).includes(model) &&
+            objHas(manifest[model], "actions") &&
+            objHas(manifest[model].actions, action)
+        ) {
+            return manifest[model].actions[action];
+        }
+        return false;
+    }
 }
 
 module.exports = notApp;

package/src/auth/abstract.js

@@ -1,8 +1,7 @@
+const CONST = require("./const");
 
-const CONST = require('./const');
-
-function isObjectString(val){
-  return Object.prototype.toString.call(val) === CONST.OBJECT_STRING;
+function isObjectString(val) {
+    return Object.prototype.toString.call(val) === CONST.OBJECT_STRING;
 }
 
 /**
@@ -13,23 +12,22 @@ function isObjectString(val){
  **/
 
 function intersect_safe(a, b) {
-  let result = [];
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (b.length > a.length) {
-      // indexOf to loop over shorter
-      let t = b;
-      b = a;
-      a = t;
+    let result = [];
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (b.length > a.length) {
+            // indexOf to loop over shorter
+            let t = b;
+            b = a;
+            a = t;
+        }
+        result = a.filter((e) => {
+            if (b.indexOf(e) !== -1) return true;
+        });
     }
-    result = a.filter((e) => {
-      if (b.indexOf(e) !== -1) return true;
-    });
-  }
-  return result;
+    return result;
 }
 
-
 module.exports = {
-  isObjectString,
-  intersect_safe
+    isObjectString,
+    intersect_safe,
 };

package/src/auth/const.js

@@ -1,17 +1,13 @@
+const DEFAULT_USER_ROLE_FOR_ADMIN = "root";
+const DEFAULT_USER_ROLE_FOR_GUEST = "guest";
 
-const DEFAULT_USER_ROLE_FOR_ADMIN = 'root';
-const DEFAULT_USER_ROLE_FOR_GUEST = 'guest';
+const OBJECT_STRING = "[object String]";
 
-const OBJECT_STRING = '[object String]';
-
-const ERR_NOT_AUTHORIZED = 'you_are_not_authorized';
-
-const DOCUMENT_OWNER_FIELD_NAME = 'ownerId';
+const DOCUMENT_OWNER_FIELD_NAME = "owner";
 
 module.exports = {
-  ERR_NOT_AUTHORIZED,
-  OBJECT_STRING,
-  DEFAULT_USER_ROLE_FOR_GUEST,
-  DEFAULT_USER_ROLE_FOR_ADMIN,
-  DOCUMENT_OWNER_FIELD_NAME
+    OBJECT_STRING,
+    DEFAULT_USER_ROLE_FOR_GUEST,
+    DEFAULT_USER_ROLE_FOR_ADMIN,
+    DOCUMENT_OWNER_FIELD_NAME,
 };

package/src/auth/fields.js

@@ -1,152 +1,171 @@
-const ABSTRACT = require('./abstract');
-const COMMON = require('../common');
-const CONST = require('./const');
-const {objHas}  = require('../common');
+const ABSTRACT = require("./abstract");
+const COMMON = require("../common");
+const CONST = require("./const");
+const { objHas } = require("../common");
 
 /**
-* Get data owner ObjectId
-* @param {Object}             data  Document Object
-* @return {ObjectId|undefined}     owner ObjectId or undefined if field is not found
-*/
-function getOwnerId(data) {
-  if(typeof data !== 'object'){return undefined;}
-  if(
-    objHas(data, CONST.DOCUMENT_OWNER_FIELD_NAME) &&
-    data[CONST.DOCUMENT_OWNER_FIELD_NAME] &&
-    COMMON.validateObjectId(data[CONST.DOCUMENT_OWNER_FIELD_NAME].toString())
-  ){
-    return data[CONST.DOCUMENT_OWNER_FIELD_NAME];
-  }
-  return undefined;
+ * Get data owner ObjectId
+ * @param {Object}             data  Document Object
+ * @return {ObjectId|undefined}     owner ObjectId or undefined if field is not found
+ */
+function getOwnerId(data, ownerFieldName = CONST.DOCUMENT_OWNER_FIELD_NAME) {
+    if (typeof data !== "object") {
+        return undefined;
+    }
+    if (
+        objHas(data, ownerFieldName) &&
+        data[ownerFieldName] &&
+        COMMON.validateObjectId(data[ownerFieldName].toString())
+    ) {
+        return data[ownerFieldName];
+    }
+    return undefined;
 }
 
 /**
-* Check if data is belongs to user
-* @param {Object}   data      object
-* @param {ObjectId} user_id   possible owner
-* @return {boolean}           true - belongs, false - not belongs
-**/
+ * Check if data is belongs to user
+ * @param {Object}   data      object
+ * @param {ObjectId} user_id   possible owner
+ * @return {boolean}           true - belongs, false - not belongs
+ **/
 
-function isOwner(data, user_id) {
-  const ownerId = getOwnerId(data);
-  return COMMON.compareObjectIds(ownerId, user_id);
+function isOwner(
+    data,
+    user_id,
+    ownerFieldName = CONST.DOCUMENT_OWNER_FIELD_NAME
+) {
+    const ownerId = getOwnerId(data, ownerFieldName);
+    return COMMON.compareObjectIds(ownerId, user_id);
 }
 
 /**
-* Checks if safe field rule is some sort variant of wild card
-* @param {string|Array<string>}   safeFor safe field rule
-* @return {boolean}               if it's wildcard
-*
-*/
-function ruleIsWildcard(safeFor){
-  if(Array.isArray(safeFor)){
-    return safeFor.includes('*');
-  }else{
-    return (safeFor === '*');
-  }
+ * Checks if safe field rule is some sort variant of wild card
+ * @param {string|Array<string>}   safeFor safe field rule
+ * @return {boolean}               if it's wildcard
+ *
+ */
+function ruleIsWildcard(safeFor) {
+    if (Array.isArray(safeFor)) {
+        return safeFor.includes("*");
+    } else {
+        return safeFor === "*";
+    }
 }
 
 /**
-* Check if field of target object is safe to access by actor with defined
-* roles in specific action
-* @param {Object}         field     description of field from schema
-* @param {string}         action    action to check against
-* @param {Array<string>}  roles     actor roles
-* @param {string}         special   special relations of actor and target (@owner, @system)
-* @return {boolean}                 true - safe
-**/
-function fieldIsSafe(field, action, roles, special){
-  //if safe absent - then field is not accessible
-  if(objHas(field, 'safe') && objHas(field.safe, action)){
-    //anyone can
-    if(ruleIsWildcard(field.safe[action])){
-      return true;
-    }
-    //if there're list of roles
-    if(!Array.isArray(field.safe[action])){
-      return false;
+ * Check if field of target object is safe to access by actor with defined
+ * roles in specific action
+ * @param {Object}         field     description of field from schema
+ * @param {string}         action    action to check against
+ * @param {Array<string>}  roles     actor roles
+ * @param {string}         special   special relations of actor and target (@owner, @system)
+ * @return {boolean}                 true - safe
+ **/
+function fieldIsSafe(field, action, roles, special) {
+    //if safe absent - then field is not accessible
+    if (objHas(field, "safe") && objHas(field.safe, action)) {
+        //anyone can
+        if (ruleIsWildcard(field.safe[action])) {
+            return true;
+        }
+        //if there're list of roles
+        if (!Array.isArray(field.safe[action])) {
+            return false;
+        }
+        if (
+            //если роли пользователя в списке
+            ABSTRACT.intersect_safe(roles, field.safe[action]).length || //или
+            //он в спец группе (владелец@owner, система@system),т.е.
+            //владеет данными или это системное действие
+            ABSTRACT.intersect_safe(special, field.safe[action]).length
+        ) {
+            return true;
+        }
     }
-    if (
-      //если роли пользователя в списке
-      ABSTRACT.intersect_safe(roles, field.safe[action]).length
-      || //или
-      //он в спец группе (владелец@owner, система@system),т.е.
-      //владеет данными или это системное действие
-      ABSTRACT.intersect_safe(special, field.safe[action]).length
-    ){
-      return true;
-    }
-  }
-  return false;
+    return false;
 }
 
 /**
-* Creates array of special roles
-* @param {boolean} owner  if actor is owner of document
-* @param {boolean} system if actor is a system process
-* @return {Array<string>} list of special roles
-**/
-function createSpecial(owner, system){
-  let special = [];
-  if (owner === true) {
-    special.push('@owner');
-  }
-  if (system === true) {
-    special.push('@system');
-  }
-  return special;
+ * Creates array of special roles
+ * @param {boolean} owner  if actor is owner of document
+ * @param {boolean} system if actor is a system process
+ * @return {Array<string>} list of special roles
+ **/
+function createSpecial(owner, system) {
+    let special = [];
+    if (owner === true) {
+        special.push("@owner");
+    }
+    if (system === true) {
+        special.push("@system");
+    }
+    return special;
 }
 
 /**
-* Scans schema checks every field access regulations for specific action of
-* actor with roles. Returns list of fields that could be accessed safely.
-* @param {Object}         schema    mongoose model schema with extended fields from not-*
-* @param {string}         action    action to check against
-* @param {Array<string>}  roles     actor roles
-* @param {boolean}        owner     actor is an owner of document
-* @param {boolean}        system    actor is a system procedure
-* @return {Array<string>}           list of accessible fields
-**/
+ * Scans schema checks every field access regulations for specific action of
+ * actor with roles. Returns list of fields that could be accessed safely.
+ * @param {Object}         schema    mongoose model schema with extended fields from not-*
+ * @param {string}         action    action to check against
+ * @param {Array<string>}  roles     actor roles
+ * @param {boolean}        owner     actor is an owner of document
+ * @param {boolean}        system    actor is a system procedure
+ * @return {Array<string>}           list of accessible fields
+ **/
 function getSafeFieldsForRoleAction(schema, action, roles, owner, system) {
-  let fields = [];
-  let special = createSpecial(owner, system);
-  for (let t in schema) {
-    let field = schema[t];
-    if (fieldIsSafe(field, action, roles, special)) {
-      fields.push(t);
+    let fields = [];
+    let special = createSpecial(owner, system);
+    for (let t in schema) {
+        let field = schema[t];
+        if (fieldIsSafe(field, action, roles, special)) {
+            fields.push(t);
+        }
     }
-  }
-  return fields;
+    return fields;
 }
 
 /**
-* Using schema and information about action and actor to extract only safe information
-* forming new object with data only from safe fields
-* @param {Object}         schema    mongoose model schema with extended fields from not-*
-* @param {string}         action    action to check against
-* @param {Object}         data      source of data to extract from
-* @param {Array<string>}  roles     actor roles
-* @param {string|ObjectId}actorId   actor objectId
-* @param {boolean}        system    true if actor is a system procedure
-* @return {Object}                  object containing only data from safe fields
-**/
-function extractSafeFields(schema, action, data, roles, actorId, system = false) {
-  let fields = getSafeFieldsForRoleAction(schema, action, roles, isOwner(data, actorId), system);
-  let result = {};
-  fields.forEach((field) => {
-    if (objHas(data, field)) {
-      result[field] = data[field];
-    }
-  });
-  return result;
+ * Using schema and information about action and actor to extract only safe information
+ * forming new object with data only from safe fields
+ * @param {Object}         schema    mongoose model schema with extended fields from not-*
+ * @param {string}         action    action to check against
+ * @param {Object}         data      source of data to extract from
+ * @param {Array<string>}  roles     actor roles
+ * @param {string|ObjectId}actorId   actor objectId
+ * @param {boolean}        system    true if actor is a system procedure
+ * @return {Object}                  object containing only data from safe fields
+ **/
+function extractSafeFields(
+    schema,
+    action,
+    data,
+    roles,
+    actorId,
+    system = false,
+    ownerFieldName = CONST.DOCUMENT_OWNER_FIELD_NAME
+) {
+    let fields = getSafeFieldsForRoleAction(
+        schema,
+        action,
+        roles,
+        isOwner(data, actorId, ownerFieldName),
+        system
+    );
+    let result = {};
+    fields.forEach((field) => {
+        if (objHas(data, field)) {
+            result[field] = data[field];
+        }
+    });
+    return result;
 }
 
 module.exports = {
-  getSafeFieldsForRoleAction,
-  fieldIsSafe,
-  extractSafeFields,
-  isOwner,
-  getOwnerId,
-  ruleIsWildcard,
-  createSpecial
+    getSafeFieldsForRoleAction,
+    fieldIsSafe,
+    extractSafeFields,
+    isOwner,
+    getOwnerId,
+    ruleIsWildcard,
+    createSpecial,
 };