not-node 5.0.22 → 5.1.2

package/src/manifest/initializator/manifests.js

@@ -1,47 +1,50 @@
-const {notError} = require('not-error');
-const {log,error} = require('not-log')(module, 'initializator');
-const {initManifestFields} = require('../../fields');
-const {firstLetterToUpper} = require('../../common');
+const { notError } = require("not-error");
+const { error } = require("not-log")(module, "initializator");
+const { initManifestFields } = require("../../fields");
+const { firstLetterToUpper } = require("../../common");
 
-module.exports = class notModuleInitializatorManifests{
-  static openFile = require;
-  constructor({nModule}){
-    this.run({nModule});
-  }
-
-  run({nModule}) {
-    const moduleName = nModule.getName();
-    for(let routeName in nModule.getRoutesManifests()) {
-      try{
-        const mod = nModule.getRouteManifest(routeName);
-        if(mod && Array.isArray(mod.fields)){
-          const rawMutationsList = [...mod.fields];
-          const ModelName = firstLetterToUpper(mod.model);
-          const schema = nModule.getModelSchema(ModelName);
-          let privateFields = [];
-          if (mod.privateFields){
-            privateFields = Array.isArray(mod.privateFields)?[...mod.privateFields]:[];
-            delete mod.privateFields;
-          }
-          mod.fields = initManifestFields(
-            nModule.getApp(),
-            schema,
-            rawMutationsList,
-            privateFields,
-            moduleName,
-          );
-        }
-      }catch(e){
-        error(`Error while initialization of route: ${moduleName}//${routeName}`);
-        if(e instanceof notError){
-          error(`name: ${e.options.field}, type: ${e.options.type}`);
-        }else{
-          error(e);
-        }
-      }
+const fieldsIsArray = (mod) => mod && Array.isArray(mod.fields);
+const extractPrivateFields = (mod) =>
+    Array.isArray(mod.privateFields) ? [...mod.privateFields] : [];
 
+module.exports = class notModuleInitializatorManifests {
+    static openFile = require;
+    constructor({ nModule }) {
+        this.run({ nModule });
     }
-  }
-
 
+    run({ nModule }) {
+        const moduleName = nModule.getName();
+        for (let routeName in nModule.getRoutesManifests()) {
+            try {
+                const mod = nModule.getRouteManifest(routeName);
+                if (fieldsIsArray(mod)) {
+                    const rawMutationsList = [...mod.fields];
+                    const ModelName = firstLetterToUpper(mod.model);
+                    const schema = nModule.getModelSchema(ModelName);
+                    let privateFields = [];
+                    if (mod.privateFields) {
+                        privateFields = extractPrivateFields(mod);
+                        delete mod.privateFields;
+                    }
+                    mod.fields = initManifestFields(
+                        nModule.getApp(),
+                        schema,
+                        rawMutationsList,
+                        privateFields,
+                        moduleName
+                    );
+                }
+            } catch (e) {
+                error(
+                    `Error while initialization of route: ${moduleName}//${routeName}`
+                );
+                if (e instanceof notError) {
+                    error(`name: ${e.options.field}, type: ${e.options.type}`);
+                } else {
+                    error(e);
+                }
+            }
+        }
+    }
 };

package/src/manifest/initializator/models.js

@@ -1,39 +1,42 @@
-const {log, error} = require('not-log')(module, 'initializator');
-const protoModel = require('../../model/proto.js');
-const {initFileSchemaFromFields} = require('../../fields');
-const {notError} = require('not-error');
+const { error } = require("not-log")(module, "initializator");
+const protoModel = require("../../model/proto.js");
+const { initFileSchemaFromFields } = require("../../fields");
+const { notError } = require("not-error");
 
-module.exports = class notModuleInitializatorModels{
-  static openFile = require;
-  constructor({nModule}){
-    this.run({nModule, app: nModule.getApp()});
-  }
+module.exports = class notModuleInitializatorModels {
+    static openFile = require;
+    constructor({ nModule }) {
+        this.run({ nModule, app: nModule.getApp() });
+    }
 
-  run({app, nModule}) {
-    const moduleName = nModule.getName();
-    for(let modelName in nModule.getModels()) {
-      try{
-        initFileSchemaFromFields({
-          app,
-          moduleName: nModule.getName(),
-          mod: nModule.getModelFile(modelName),
-          type: 'model',
-          from: ':FIELDS',
-          to:   ':thisSchema',
-        });
-        protoModel.fabricate(nModule.getModelFile(modelName), nModule.getOptions(), nModule.mongoose);
-        //log(`${moduleName}//${modelName}`);
-      }catch(e){
-        error(`Error while initialization of model: ${moduleName}//${modelName}`);
-        if(e instanceof notError){
-          error(`name: ${e.options.field}, type: ${e.options.type}`);
-        }else{
-          error(e);
+    run({ app, nModule }) {
+        const moduleName = nModule.getName();
+        for (let modelName in nModule.getModels()) {
+            try {
+                initFileSchemaFromFields({
+                    app,
+                    moduleName: nModule.getName(),
+                    mod: nModule.getModelFile(modelName),
+                    type: "model",
+                    from: ":FIELDS",
+                    to: ":thisSchema",
+                });
+                protoModel.fabricate(
+                    nModule.getModelFile(modelName),
+                    nModule.getOptions(),
+                    nModule.mongoose
+                );
+                //log(`${moduleName}//${modelName}`);
+            } catch (e) {
+                error(
+                    `Error while initialization of model: ${moduleName}//${modelName}`
+                );
+                if (e instanceof notError) {
+                    error(`name: ${e.options.field}, type: ${e.options.type}`);
+                } else {
+                    error(e);
+                }
+            }
         }
-      }
-
     }
-  }
-
-
 };

package/src/manifest/manifest.filter.js

@@ -1,112 +1,145 @@
-const merge = require('deepmerge');
-const Auth = require('../auth');
+const merge = require("deepmerge");
+const Auth = require("../auth");
 
-const DIRTY_FIELDS = ['rules', 'admin', 'root', 'safe', 'auth', 'role', 'actionName', 'actionPrefix'];
+const DIRTY_FIELDS = [
+    "rules",
+    "admin",
+    "root",
+    "safe",
+    "auth",
+    "role",
+    "actionName",
+    "actionPrefix",
+];
 
 module.exports = class notManifestFilter {
-  /**
-   *  Clear route from action variants that not permited for user according to
-   *  his auth, role, root status
-   *
-   *  @param {object}   route  route object
-   *  @param {boolean}  auth  user auth status
-   *  @param {boolean}  role  user role status
-   *  @param {boolean}  root  user root status
-   *
-   *  @return {object}  Return router with only actions user can access with current states of auth, role, root. With removed definitions of what rules of access are.
-   **/
-  static filterRoute(route, auth, role, root) {
-    let result = JSON.parse(JSON.stringify(route));
-    result.actions = {};
-    if (!route || !route.actions) {
-      return result;
-    }
-    for (let actionName in route.actions) {
-      if (!route.actions[actionName]) {
-        continue;
-      }
-      let actionSet = route.actions[actionName];
-      notManifestFilter.filterRouteAction(actionName, actionSet, auth, role, root, result);
+    /**
+     *  Clear route from action variants that not permited for user according to
+     *  his auth, role, root status
+     *
+     *  @param {object}   route  route object
+     *  @param {boolean}  auth  user auth status
+     *  @param {boolean}  role  user role status
+     *  @param {boolean}  root  user root status
+     *
+     *  @return {object}  Return router with only actions user can access with current states of auth, role, root. With removed definitions of what rules of access are.
+     **/
+    static filterRoute(route, auth, role, root) {
+        let result = JSON.parse(JSON.stringify(route));
+        result.actions = {};
+        if (!route || !route.actions) {
+            return result;
+        }
+        for (let actionName in route.actions) {
+            if (!route.actions[actionName]) {
+                continue;
+            }
+            let actionSet = route.actions[actionName];
+            notManifestFilter.filterRouteAction(
+                actionName,
+                actionSet,
+                auth,
+                role,
+                root,
+                result
+            );
+        }
+        return result;
     }
-    return result;
-  }
 
-  /**
-  *
-  */
-  static filterRouteAction(actionName, actionSet, auth, role, root, result) {
-    if (Array.isArray(actionSet.rules)) {
-      for (let i = 0; i < actionSet.rules.length; i++) {
-        if (Auth.checkCredentials(actionSet.rules[i], auth, role, root)) {
-          result.actions[actionName] = notManifestFilter.clearActionFromRules(actionSet, actionSet.rules[i]);
-          break;
+    /**
+     *
+     */
+    static filterRouteAction(actionName, actionSet, auth, role, root, result) {
+        if (Array.isArray(actionSet.rules)) {
+            for (let i = 0; i < actionSet.rules.length; i++) {
+                if (
+                    Auth.checkCredentials(actionSet.rules[i], auth, role, root)
+                ) {
+                    result.actions[actionName] =
+                        notManifestFilter.clearActionFromRules(
+                            actionSet,
+                            actionSet.rules[i]
+                        );
+                    break;
+                }
+            }
+        } else {
+            if (Auth.checkCredentials(actionSet, auth, role, root)) {
+                result.actions[actionName] =
+                    notManifestFilter.clearActionFromRules(actionSet);
+            }
         }
-      }
-    } else {
-      if (Auth.checkCredentials(actionSet, auth, role, root)) {
-        result.actions[actionName] = notManifestFilter.clearActionFromRules(actionSet);
-      }
     }
-  }
 
-  /**
-   *  Filters manifest for current user auth, role, root.
-   *  Removes all actions that can not be performed
-   *
-   *  @param {object}   manifest  full raw manifest
-   *  @param {boolean}  auth    user auth status
-   *  @param {boolean}  role    user role status
-   *  @param {boolean}  root    user root status
-   *
-   *  @return {object}  filtered manifest
-   **/
+    /**
+     *  Filters manifest for current user auth, role, root.
+     *  Removes all actions that can not be performed
+     *
+     *  @param {object}   manifest  full raw manifest
+     *  @param {boolean}  auth    user auth status
+     *  @param {boolean}  role    user role status
+     *  @param {boolean}  root    user root status
+     *
+     *  @return {object}  filtered manifest
+     **/
 
-  static filter(manifest, auth, role, root) {
-    var result = {};
-    for (let routeName in manifest) {
-      let routeMan = notManifestFilter.filterRoute(manifest[routeName], auth, role, root);
-      if (Object.keys(routeMan.actions).length > 0) {
-        result[routeName] = routeMan;
-      }
+    static filter(manifest, auth, role, root) {
+        var result = {};
+        for (let routeName in manifest) {
+            let routeMan = notManifestFilter.filterRoute(
+                manifest[routeName],
+                auth,
+                role,
+                root
+            );
+            if (Object.keys(routeMan.actions).length > 0) {
+                result[routeName] = routeMan;
+            }
+        }
+        return result;
     }
-    return result;
-  }
 
-  /**
-   * Return true if ruleSet object has not empty list of fields
-   * @param {Object} ruleSet specific set of rules for action
-   * @return {boolean} if rule set has not empty fields list
-   */
-  static ruleSetHasFieldsDirective(ruleSet) {
-    return (typeof ruleSet !== 'undefined' && ruleSet !== null) && (ruleSet.fields && Array.isArray(ruleSet.fields) && ruleSet.fields.length);
-  }
-
-  /**
-   *  Clear action definition from rules of access
-   *  @param  {object}  action   action data
-   *  @param  {object}  ruleSet specific set of rules for this action
-   *  @return  {object}  clean action data
-   **/
-  static clearActionFromRules(action, ruleSet = null) {
-    let copy = merge({}, action);
-    notManifestFilter.clearFromDirtyFields(copy);
-    //copy fields list from rule to action if it exists
-    //fields list is used to restrict fields of data that could be accessed via
-    //this action
-    if (notManifestFilter.ruleSetHasFieldsDirective(ruleSet)) {
-      copy.fields = [...ruleSet.fields];
+    /**
+     * Return true if ruleSet object has not empty list of fields
+     * @param {Object} ruleSet specific set of rules for action
+     * @return {boolean} if rule set has not empty fields list
+     */
+    static ruleSetHasFieldsDirective(ruleSet) {
+        return (
+            typeof ruleSet !== "undefined" &&
+            ruleSet !== null &&
+            ruleSet.fields &&
+            Array.isArray(ruleSet.fields) &&
+            ruleSet.fields.length
+        );
     }
-    return copy;
-  }
 
+    /**
+     *  Clear action definition from rules of access
+     *  @param  {object}  action   action data
+     *  @param  {object}  ruleSet specific set of rules for this action
+     *  @return  {object}  clean action data
+     **/
+    static clearActionFromRules(action, ruleSet = null) {
+        let copy = merge({}, action);
+        notManifestFilter.clearFromDirtyFields(copy);
+        //copy fields list from rule to action if it exists
+        //fields list is used to restrict fields of data that could be accessed via
+        //this action
+        if (notManifestFilter.ruleSetHasFieldsDirective(ruleSet)) {
+            copy.fields = [...ruleSet.fields];
+        }
+        return copy;
+    }
 
-  /**
-  * Deletes fields listed in DIRTY_FIELDS constant from object
-  * @param {Object} action action object
-  **/
-  static clearFromDirtyFields(action) {
-    DIRTY_FIELDS.forEach(fieldName => {
-      delete action[fieldName];
-    });
-  }
+    /**
+     * Deletes fields listed in DIRTY_FIELDS constant from object
+     * @param {Object} action action object
+     **/
+    static clearFromDirtyFields(action) {
+        DIRTY_FIELDS.forEach((fieldName) => {
+            delete action[fieldName];
+        });
+    }
 };

package/src/manifest/manifest.js

@@ -1,10 +1,9 @@
-const Parser = require('../parser');
-const Route = require('./route');
+const Parser = require("../parser");
+const Route = require("./route");
 
-const {objHas}  = require('../common');
-
-const notManifestFilter = require('./manifest.filter.js');
+const { objHas } = require("../common");
 
+const notManifestFilter = require("./manifest.filter.js");
 
 /**
  *  API manifest
@@ -14,86 +13,113 @@ const notManifestFilter = require('./manifest.filter.js');
  *  @param  {string}  moduleName  name of owner module
  **/
 class notManifest {
-  constructor(app, notApp, moduleName) {
-    this.app = app;
-    this.notApp = notApp;
-    this.moduleName = moduleName;
-    return this;
-  }
+    constructor(app, notApp, moduleName) {
+        this.app = app;
+        this.notApp = notApp;
+        this.moduleName = moduleName;
+        return this;
+    }
 
-  /**
-   *  Создаем путь для одной конечной точки
-   *
-   *  @param  {object}  app        express app object
-   *  @param  {string}  routesPath    directory where routes files is placed
-   *  @param  {string}  routeLine    aka '/login', '/user/:id', etc
-   *  @param  {string}  modelName    name of the mongoose model, should be exact as file name with routes for this model. If /models/theme.js contains 'Theme' mongoose model, then /routes/theme.js should  `
-   *  contain routes for that model.
-   *  @param  {string}  actionSetName  name of action in routes file. Look for existing route file for understanding
-   *  @param  {object}  actionData    representation of action data
-   *
-   *  @return  {boolean}  if route were registered
-   **/
+    /**
+     *  Создаем путь для одной конечной точки
+     *
+     *  @param  {object}  app        express app object
+     *  @param  {string}  routesPath    directory where routes files is placed
+     *  @param  {string}  routeLine    aka '/login', '/user/:id', etc
+     *  @param  {string}  modelName    name of the mongoose model, should be exact as file name with routes for this model. If /models/theme.js contains 'Theme' mongoose model, then /routes/theme.js should  `
+     *  contain routes for that model.
+     *  @param  {string}  actionSetName  name of action in routes file. Look for existing route file for understanding
+     *  @param  {object}  actionData    representation of action data
+     *
+     *  @return  {boolean}  if route were registered
+     **/
 
-  registerRouteForAction(routeLine, routeName, actionName, actionData) {
-    if (actionData && actionData.method) {
-      const routerAction = new Route(this.notApp, this.moduleName, routeName, actionName, actionData);
-      this.app[actionData.method.toLowerCase()](routeLine, routerAction.exec.bind(routerAction));
-      return true;
-    } else {
-      return false;
+    registerRouteForAction(routeLine, routeName, actionName, actionData) {
+        if (actionData && actionData.method) {
+            const routerAction = new Route(
+                this.notApp,
+                this.moduleName,
+                routeName,
+                actionName,
+                actionData
+            );
+            this.app[actionData.method.toLowerCase()](
+                routeLine,
+                routerAction.exec.bind(routerAction)
+            );
+            return true;
+        } else {
+            return false;
+        }
     }
-  }
 
-  /**
-   *  Создаем пути согласно манифесту
-   *
-   *  @param  {object}  moduleManifest  notManifest of module
-   **/
-  registerRoutes(moduleManifest) {
-    Object.values(moduleManifest).forEach(route => this.registerRoute(route));
-  }
-
-  /**
-  * Check if manifest file has url, model and actions, so we could register routes
-  * @param  {object}  route   content of .manifest.js file
-  * @return {boolean}         true if could create routes
-  **/
-  routeHasRoutes(route){
-    return objHas(route, 'actions') && objHas(route, 'url') && (objHas(route, 'model') && route.model !== '');
-  }
+    /**
+     *  Создаем пути согласно манифесту
+     *
+     *  @param  {object}  moduleManifest  notManifest of module
+     **/
+    registerRoutes(moduleManifest) {
+        Object.values(moduleManifest).forEach((route) =>
+            this.registerRoute(route)
+        );
+    }
 
-  /**
-  * Check if manifest file has url and actions, so we could register routes
-  * @param  {object}  moduleManifest    library of .manifest.js files
-  * @param  {string}  routeName         name of
-  **/
-  registerRoute(route){
-    if(!this.routeHasRoutes(route)){return;}
-    const routeName = route.model;
-    Object.keys(route.actions).forEach((actionName)=>{
-      const actionData = route.actions[actionName];
-      const routeLine = Parser.getRouteLine(route.url, routeName, actionName, actionData);
-      this.registerRouteForAction(routeLine, routeName, actionName, actionData);
-    });
-  }
+    /**
+     * Check if manifest file has url, model and actions, so we could register routes
+     * @param  {object}  route   content of .manifest.js file
+     * @return {boolean}         true if could create routes
+     **/
+    routeHasRoutes(route) {
+        return (
+            objHas(route, "actions") &&
+            objHas(route, "url") &&
+            objHas(route, "model") &&
+            route.model !== ""
+        );
+    }
 
-  /**
-   *  Filters manifest for current user auth, role, root.
-   *  Removes all actions that can not be performed
-   *
-   *  @param {object}   manifest  full raw manifest
-   *  @param {boolean}  auth    user auth status
-   *  @param {boolean}  role    user role status
-   *  @param {boolean}  root    user root status
-   *
-   *  @return {object}  filtered manifest
-   **/
+    /**
+     * Check if manifest file has url and actions, so we could register routes
+     * @param  {object}  moduleManifest    library of .manifest.js files
+     * @param  {string}  routeName         name of
+     **/
+    registerRoute(route) {
+        if (!this.routeHasRoutes(route)) {
+            return;
+        }
+        const routeName = route.model;
+        Object.keys(route.actions).forEach((actionName) => {
+            const actionData = route.actions[actionName];
+            const routeLine = Parser.getRouteLine(
+                route.url,
+                routeName,
+                actionName,
+                actionData
+            );
+            this.registerRouteForAction(
+                routeLine,
+                routeName,
+                actionName,
+                actionData
+            );
+        });
+    }
 
-  filterManifest(manifest, auth, role, root) {
-    return notManifestFilter.filter(manifest, auth, role, root);
-  }
+    /**
+     *  Filters manifest for current user auth, role, root.
+     *  Removes all actions that can not be performed
+     *
+     *  @param {object}   manifest  full raw manifest
+     *  @param {boolean}  auth    user auth status
+     *  @param {boolean}  role    user role status
+     *  @param {boolean}  root    user root status
+     *
+     *  @return {object}  filtered manifest
+     **/
 
+    filterManifest(manifest, auth, role, root) {
+        return notManifestFilter.filter(manifest, auth, role, root);
+    }
 }
 
 module.exports = notManifest;