not-node 6.3.77 → 6.3.79

package/package.json

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

package/src/auth/const.js

@@ -23,6 +23,7 @@ const METHOD_SIGNAURES = {
     GET: ACTION_SIGNATURES.READ,
     PUT: ACTION_SIGNATURES.CREATE,
     POST: ACTION_SIGNATURES.UPDATE,
+    PATCH: ACTION_SIGNATURES.UPDATE,
     DELETE: ACTION_SIGNATURES.DELETE,
 };
 

package/src/domain.js

@@ -326,6 +326,21 @@ class notDomain extends EventEmitter {
         return this;
     }
 
+    warn() {
+        this.logger.warn(...arguments);
+        return this;
+    }
+
+    error() {
+        this.logger.error(...arguments);
+        return this;
+    }
+
+    debug() {
+        this.logger.debug(...arguments);
+        return this;
+    }
+
     /**
      *  reporter - errors
      */

package/src/manifest/manifest.filter.js

@@ -95,7 +95,10 @@ module.exports = class notManifestFilter {
                                 root,
                                 modelName,
                                 moduleName,
-                                actionSignature: actionSet.actionSignature,
+                                actionSignature:
+                                    notManifestFilter.detectActionSignature(
+                                        actionSet
+                                    ),
                             }
                         );
                     break;
@@ -113,7 +116,10 @@ module.exports = class notManifestFilter {
                             root,
                             modelName,
                             moduleName,
-                            actionSignature: actionSet.actionSignature,
+                            actionSignature:
+                                notManifestFilter.detectActionSignature(
+                                    actionSet
+                                ),
                         }
                     );
             }
@@ -165,6 +171,24 @@ module.exports = class notManifestFilter {
         );
     }
 
+    /**
+     * Return true if ruleSet object has not empty list of return and return is an Array<string>
+     * @param {Object} ruleSet specific set of rules for action
+     * @return {boolean} if rule set has not empty fields list
+     */
+    static ruleSetHasReturnDirectiveInAllStringFormat(ruleSet) {
+        return (
+            typeof ruleSet !== "undefined" &&
+            ruleSet !== null &&
+            ruleSet.return &&
+            Array.isArray(ruleSet.return) &&
+            ruleSet.return.length &&
+            ruleSet.return.every(
+                (returnFieldName) => typeof returnFieldName === "string"
+            )
+        );
+    }
+
     static composeFullModelName(moduleName, modelName) {
         if (modelName) {
             if (moduleName) {
@@ -184,6 +208,36 @@ module.exports = class notManifestFilter {
         }
     }
 
+    /**
+     *
+     * Returns Action signature for action
+     * @static
+     * @param {import('../types').notActionData} action
+     * @return {string}
+     */
+    static detectActionSignature(action) {
+        if (action) {
+            switch (action?.method?.toLocaleLowerCase()) {
+                case "get":
+                    return Auth.ACTION_SIGNATURES.READ;
+
+                case "post":
+                case "patch":
+                    return Auth.ACTION_SIGNATURES.UPDATE;
+
+                case "put":
+                    return Auth.ACTION_SIGNATURES.CREATE;
+
+                case "delete":
+                    return Auth.ACTION_SIGNATURES.DELETE;
+
+                default:
+                    return Auth.ACTION_SIGNATURES.READ;
+            }
+        }
+        return Auth.ACTION_SIGNATURES.READ;
+    }
+
     /**
      *  Clear action definition from rules of access
      *  @param      {object}                action   action data
@@ -221,16 +275,26 @@ module.exports = class notManifestFilter {
         //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
+        const fullModelName = this.composeFullModelName(moduleName, modelName);
+        const modelSchema = this.loadSchema(fullModelName);
         if (notManifestFilter.ruleSetHasFieldsDirective(ruleSet)) {
-            const fullModelName = this.composeFullModelName(
-                moduleName,
-                modelName
-            );
             copy.fields = notFieldsFilter.filter(
                 [...ruleSet.fields],
-                this.loadSchema(fullModelName),
+                modelSchema,
+                { action: actionSignature, roles: role, auth, root, modelName }
+            );
+        }
+        if (
+            notManifestFilter.ruleSetHasReturnDirectiveInAllStringFormat(
+                ruleSet
+            )
+        ) {
+            copy.return = notFieldsFilter.filter(
+                [...ruleSet.return],
+                modelSchema,
                 { action: actionSignature, roles: role, auth, root, modelName }
             );
+            //console.log(fullModelName, ruleSet.return, ' - > ',copy.return);
         }
         return copy;
     }