not-node 6.3.0 → 6.3.2

package/src/identity/providers/token.js

@@ -40,7 +40,6 @@ module.exports = class IdentityProviderToken {
         const auth = req.get("Authorization");
         if (auth && auth.length) {
             const [, token] = auth.split(" ");
-            console.log("token found", token);
             return token;
         }
         return null;
@@ -58,6 +57,10 @@ module.exports = class IdentityProviderToken {
         return this.#token;
     }
 
+    /**
+     *
+     * @returns {Object}
+     */
     #decodeTokenContent() {
         try {
             if (this.#token) {
@@ -85,8 +88,11 @@ module.exports = class IdentityProviderToken {
         }
     }
 
-    #extractTokenContent(req) {
-        this.#tokenContent = this.#decodeTokenContent(req);
+    /**
+     * Decodes raw token and sets token object as #tokenContent
+     */
+    #extractTokenContent() {
+        this.#tokenContent = this.#decodeTokenContent();
     }
 
     get tokenContent() {
@@ -221,7 +227,9 @@ module.exports = class IdentityProviderToken {
      **/
     setUserId(_id) {
         if (this.tokenContent) {
-            this.#tokenContent._id = _id;
+            if (_id === "") {
+                this.#tokenContent && delete this.#tokenContent._id;
+            }
             this.#updateToken();
         }
         return this;
@@ -254,7 +262,7 @@ module.exports = class IdentityProviderToken {
     /**
      *	Set auth data in session, user id and role
      *	@param	{string}	id 		user id
-     *	@param	{string}	role 	user role
+     *	@param	{Array<string>}	role 	user role
      **/
     setAuth(id, role) {
         this.setUserId(id);
@@ -265,12 +273,11 @@ module.exports = class IdentityProviderToken {
      *	Set auth data in token to Guest
      **/
     setGuest() {
-        this.setAuth(null, [CONST.DEFAULT_USER_ROLE_FOR_GUEST]);
+        this.setAuth("", [CONST.DEFAULT_USER_ROLE_FOR_GUEST]);
     }
 
     /**
      *	Reset session
-     *	@param	{object}	req 	Express Request
      **/
     cleanse() {
         this.setGuest();

package/src/init/lib/sessions/index.js

@@ -30,7 +30,7 @@ module.exports = class InitSessions {
                 emit,
             });
         } else {
-            log("no session options");
+            log && log.log("no session options");
         }
     }
 };

package/src/manifest/manifest.filter.js

@@ -1,5 +1,7 @@
 const merge = require("deepmerge");
 const Auth = require("../auth");
+const notFieldsFilter = require("../fields/filter");
+const getApp = require("../getApp");
 
 const DIRTY_FIELDS = [
     "rules",
@@ -10,22 +12,27 @@ const DIRTY_FIELDS = [
     "role",
     "actionName",
     "actionPrefix",
+    "actionSignature",
 ];
 
 module.exports = class notManifestFilter {
+    static schemaLoader = (name) => getApp().getModelSchema(name);
+
     /**
      *  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
+     *  @param {object}         route           route object
+     *  @param {boolean}        auth            user auth status
+     *  @param {Array<string>}  role            user role status
+     *  @param {boolean}        root            user root status
+     *  @param {string}         [moduleName='']      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) {
+    static filterRoute(route, auth, role, root, moduleName = "") {
         let result = JSON.parse(JSON.stringify(route));
+        const modelName = result.modelName;
         result.actions = {};
         if (!route || !route.actions) {
             return result;
@@ -41,7 +48,9 @@ module.exports = class notManifestFilter {
                 auth,
                 role,
                 root,
-                result
+                result,
+                modelName,
+                moduleName
             );
         }
         return result;
@@ -49,8 +58,27 @@ module.exports = class notManifestFilter {
 
     /**
      *
+     *
+     * @static
+     * @param {string}                              actionName
+     * @param {import('../types').notActionData}    actionSet
+     * @param {boolean}                             auth
+     * @param {Array<string>}                       role
+     * @param {boolean}                             root
+     * @param {any}                                 result
+     * @param {string}                              [modelName=""]
+     * @param {string}                              [moduleName=""]
      */
-    static filterRouteAction(actionName, actionSet, auth, role, root, result) {
+    static filterRouteAction(
+        actionName,
+        actionSet,
+        auth,
+        role,
+        root,
+        result,
+        modelName = "",
+        moduleName = ""
+    ) {
         if (Array.isArray(actionSet.rules)) {
             for (let i = 0; i < actionSet.rules.length; i++) {
                 if (
@@ -59,7 +87,15 @@ module.exports = class notManifestFilter {
                     result.actions[actionName] =
                         notManifestFilter.clearActionFromRules(
                             actionSet,
-                            actionSet.rules[i]
+                            actionSet.rules[i],
+                            {
+                                auth,
+                                role,
+                                root,
+                                modelName,
+                                moduleName,
+                                actionSignature: actionSet.actionSignature,
+                            }
                         );
                     break;
                 }
@@ -67,7 +103,18 @@ module.exports = class notManifestFilter {
         } else {
             if (Auth.checkCredentials(actionSet, auth, role, root)) {
                 result.actions[actionName] =
-                    notManifestFilter.clearActionFromRules(actionSet);
+                    notManifestFilter.clearActionFromRules(
+                        actionSet,
+                        undefined,
+                        {
+                            auth,
+                            role,
+                            root,
+                            modelName,
+                            moduleName,
+                            actionSignature: actionSet.actionSignature,
+                        }
+                    );
             }
         }
     }
@@ -78,20 +125,22 @@ module.exports = class notManifestFilter {
      *
      *  @param {object}   manifest  full raw manifest
      *  @param {boolean}  auth    user auth status
-     *  @param {boolean}  role    user role status
+     *  @param {Array<string>}  role    user role status
      *  @param {boolean}  root    user root status
+     *  @param {string}     [moduleName='']
      *
      *  @return {object}  filtered manifest
      **/
 
-    static filter(manifest, auth, role, root) {
+    static filter(manifest, auth, role, root, moduleName = "") {
         var result = {};
         for (let routeName in manifest) {
             let routeMan = notManifestFilter.filterRoute(
                 manifest[routeName],
                 auth,
                 role,
-                root
+                root,
+                moduleName
             );
             if (Object.keys(routeMan.actions).length > 0) {
                 result[routeName] = routeMan;
@@ -115,20 +164,72 @@ module.exports = class notManifestFilter {
         );
     }
 
+    static composeFullModelName(moduleName, modelName) {
+        if (modelName) {
+            if (moduleName) {
+                return `${moduleName}//${modelName}`;
+            } else {
+                return `${modelName}`;
+            }
+        }
+        return "";
+    }
+
+    static loadSchema(fullModelName) {
+        if (fullModelName !== "") {
+            return this.schemaLoader(fullModelName);
+        } else {
+            return {};
+        }
+    }
+
     /**
      *  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
+     *  @param      {object}                action   action data
+     *  @param      {object}                [ruleSet] specific set of rules for this action
+     *  @param      {object}                mods specific set of rules for this action
+     *  @param      {boolean}               mods.auth
+     *  @param      {boolean}               mods.root
+     *  @param      {Array<string>}         mods.role
+     *  @param      {string}                mods.modelName
+     *  @param      {string}                mods.moduleName
+     *  @param      {string|undefined}                mods.actionSignature    create/read/update/delete
+     *  @return     {object}               clean action data
      **/
-    static clearActionFromRules(action, ruleSet = null) {
+    static clearActionFromRules(
+        action,
+        ruleSet = null,
+        {
+            auth = false,
+            role = [Auth.DEFAULT_USER_ROLE_FOR_GUEST],
+            root = false,
+            modelName = "",
+            moduleName = "",
+            actionSignature = undefined,
+        } = {
+            auth: false,
+            role: [Auth.DEFAULT_USER_ROLE_FOR_GUEST],
+            root: false,
+            modelName: "",
+            moduleName: "",
+            actionSignature: undefined,
+        }
+    ) {
         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];
+            const fullModelName = this.composeFullModelName(
+                moduleName,
+                modelName
+            );
+            copy.fields = notFieldsFilter.filter(
+                [...ruleSet.fields],
+                this.loadSchema(fullModelName),
+                { action: actionSignature, roles: role, auth, root, modelName }
+            );
         }
         return copy;
     }

package/src/manifest/manifest.js

@@ -111,14 +111,20 @@ class notManifest {
      *
      *  @param {object}   manifest  full raw manifest
      *  @param {boolean}  auth    user auth status
-     *  @param {boolean}  role    user role status
+     *  @param {Array<string>}  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);
+        return notManifestFilter.filter(
+            manifest,
+            auth,
+            role,
+            root,
+            this.moduleName
+        );
     }
 }
 

package/src/manifest/module.js

@@ -18,7 +18,7 @@ const DEFAULT_WS_ROUTE_ACTION_SPLITTER = "//";
 /**
  * List of methods to be binded from notApp to notModule
  * @constant
- * @type {string}
+ * @type {Array<string>}
  */
 const MODULE_BINDINGS_LIST = ["getModel", "getModelSchema", "getModelFile"];
 /**
@@ -62,12 +62,12 @@ class notModule {
         if (this.path) {
             this.initFromPath(this.path);
         } else if (this.module) {
-            this.initFromModule(this.module);
+            this.initFromModule();
         } else {
             return false;
         }
         if (this.module === null || typeof this.module === "undefined") {
-            log.error(`Module ${this.path} not loaded`);
+            log && log.error(`Module ${this.path} not loaded`);
         } else if (this.appIsSet()) {
             mapBind(this.notApp, this.module, MODULE_BINDINGS_LIST);
         }
@@ -83,7 +83,7 @@ class notModule {
             }
         } catch (e) {
             this.faulty = true;
-            log.error(e);
+            log && log.error(e);
         }
     }
 
@@ -92,7 +92,7 @@ class notModule {
             this.registerContent();
         } catch (e) {
             this.faulty = true;
-            log.error(e);
+            log && log.error(e);
         }
     }
 
@@ -107,11 +107,14 @@ class notModule {
     getManifest(
         { auth, role, root } = {
             auth: false,
-            role: Auth.DEFAULT_USER_ROLE_FOR_GUEST,
+            role: [Auth.DEFAULT_USER_ROLE_FOR_GUEST],
             root: false,
         }
     ) {
-        return this.manifest.filterManifest(this.manifests, auth, role, root);
+        return (
+            this.manifest &&
+            this.manifest.filterManifest(this.manifests, auth, role, root)
+        );
     }
 
     getRouteManifest(name) {
@@ -172,7 +175,7 @@ class notModule {
         if (this.manifests && expressApp) {
             notModuleInitializator.exec({ nModule: this });
             this.initManifest(expressApp, moduleName);
-            this.manifest.registerRoutes(this.manifests);
+            this.manifest && this.manifest.registerRoutes(this.manifests);
         }
     }
 
@@ -182,9 +185,10 @@ class notModule {
 
     async exec(methodName, params) {
         if (!this.module) {
-            log.error(
-                `Cant exec ${methodName} in module ${this.path}, module not loaded`
-            );
+            log &&
+                log.error(
+                    `Cant exec ${methodName} in module ${this.path}, module not loaded`
+                );
             return false;
         }
         await executeObjectFunction(this.module, methodName, [
@@ -369,11 +373,12 @@ class notModule {
         const status = this.getStatus();
         Object.keys(status).forEach((contentType) => {
             if (status[contentType].count) {
-                log.log(
-                    `${this.getName()} ${contentType}(${
-                        status[contentType].count
-                    }): ${status[contentType].list.join(", ")}`
-                );
+                log &&
+                    log.log(
+                        `${this.getName()} ${contentType}(${
+                            status[contentType].count
+                        }): ${status[contentType].list.join(", ")}`
+                    );
             }
         });
     }

package/src/manifest/registrator/fields.js

@@ -83,7 +83,7 @@ module.exports = class notModuleRegistratorFields {
     /**
      * Searching fields in directory
      * @param {Object}     input
-     * @param {notModule}  input.notModule
+     * @param {import('../module')}  input.nModule
      * @param {string}     input.srcDir
      **/
     findAll({ nModule, srcDir }) {
@@ -96,6 +96,13 @@ module.exports = class notModuleRegistratorFields {
         });
     }
 
+    /**
+     * Registering fields from specific path
+     *
+     * @param {Object}     input
+     * @param {import('../module')}  input.nModule
+     * @param {string}     input.fromPath
+     */
     register({ nModule, fromPath }) {
         let file = notModuleRegistratorFields.openFile(fromPath);
         if (file && objHas(file, "FIELDS")) {

package/src/manifest/registrator/forms.js

@@ -29,6 +29,7 @@ module.exports = class notModuleRegistratorForms {
      * Searching forms in directory
      * @param {Object}     input
      * @param {string}     input.srcDir
+     * @param {import('../module')} input.nModule
      **/
     findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) => {

package/src/manifest/registrator/locales.js

@@ -6,12 +6,20 @@ module.exports = class notModuleRegistratorLocales {
         this.run({ nModule });
     }
 
+    /**
+     *
+     * @param {object}                  input
+     * @param {import('../module')}     input.nModule
+     * @return {boolean}
+     */
     run({ nModule }) {
         const srcDir = notModuleRegistratorLocales.getPath(nModule);
         if (!srcDir) {
             return false;
         }
-        notLocale.fromDir(srcDir, nModule.getName()).catch(log.error);
+        notLocale
+            .fromDir(srcDir, nModule.getName())
+            .catch((e) => log && log.error(e));
         return true;
     }
 

package/src/manifest/registrator/logics.js

@@ -6,7 +6,7 @@ const { tryFile, mapBind } = require("../../common");
 /**
  * List of methods to be binded from notApp to logics
  * @constant
- * @type {string}
+ * @type {Array<string>}
  **/
 const LOGIC_BINDINGS_LIST = [
     "getModel",
@@ -44,7 +44,7 @@ module.exports = class notModuleRegistratorLogics {
      * Searching fields in directory
      * @static
      * @param {Object}     input
-     * @param {notModule}  input.notModule
+     * @param {import('../module')}  input.nModule
      * @param {string}     input.srcDir
      **/
     findAll({ nModule, srcDir }) {

package/src/manifest/registrator/models.js

@@ -6,7 +6,7 @@ const { tryFile, mapBind } = require("../../common");
 /**
  * List of methods to be binded from notApp to models
  * @constant
- * @type {string}
+ * @type {Array<string>}
  **/
 const MODEL_BINDINGS_LIST = [
     "getModel",
@@ -41,7 +41,7 @@ module.exports = class notModuleRegistratorModels {
      * Searching fields in directory
      * @static
      * @param {Object}     input
-     * @param {notModule}  input.notModule
+     * @param {import('../module')}  input.nModule
      * @param {string}     input.srcDir
      **/
     findAll({ nModule, srcDir }) {

package/src/manifest/registrator/routes.js

@@ -10,28 +10,28 @@ const notModuleRegistratorRoutesWS = require("./routes.ws");
 /**
  * Manifest files ending
  * @constant
- * @type {string}
+ * @type {Array<string>}
  */
 const DEFAULT_MANIFEST_FILE_ENDINGS = [".manifest.js", ".manifest.cjs"];
 
 /**
  * Routes collection files ending
  * @constant
- * @type {string}
+ * @type {Array<string>}
  */
 const DEFAULT_ROUTES_FILE_ENDINGS = [".js", ".cjs"];
 
 /**
  * WS End-points collection files ending
  * @constant
- * @type {string}
+ * @type {Array<string>}
  */
 const DEFAULT_WS_ROUTES_FILE_ENDINGS = [".ws.js", ".ws.cjs"];
 
 /**
  * List of methods to be binded from notApp to routes and WS end-points
  * @constant
- * @type {string}
+ * @type {Array<string>}
  */
 const ROUTE_BINDINGS_LIST = [
     "getLogic",
@@ -68,9 +68,9 @@ module.exports = class notModuleRegistratorRoutes {
     /**
      * Searching fields in directory
      * @static
-     * @param {Object}     input
-     * @param {notModule}  input.notModule
-     * @param {string}     input.srcDir
+     * @param {Object}                  input
+     * @param {import('../module')}     input.nModule
+     * @param {string}                  input.srcDir
      **/
     findAll({ nModule, srcDir }) {
         fs.readdirSync(srcDir).forEach((file) =>
@@ -127,7 +127,7 @@ module.exports = class notModuleRegistratorRoutes {
             });
             return true;
         } catch (e) {
-            log.error(e);
+            log && log.error(e);
             return false;
         }
     }

package/src/manifest/result.filter.js

@@ -134,7 +134,8 @@ module.exports = class notManifestRouteResultFilter {
         for (let filteringTargetName of filteringArray) {
             const subTarget = notPath.get(
                 `${notPath.PATH_START_OBJECT}${filteringTargetName}`,
-                target
+                target,
+                {}
             );
             //if sub target Array filtering each item individualy
             if (Array.isArray(subTarget)) {
@@ -231,7 +232,7 @@ module.exports = class notManifestRouteResultFilter {
     static getFilteringTarget(result, notRouteData) {
         if (result && typeof result == "object") {
             const returnListRoot = this.getFilteringTargetPath(notRouteData);
-            return notPath.get(returnListRoot, result);
+            return notPath.get(returnListRoot, result, {});
         } else {
             return result;
         }