not-node 6.5.31 → 6.5.33

package/package.json

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

package/src/core/fields/validators/identity.js

@@ -50,8 +50,12 @@ module.exports = [
         message: "not-node:identity_field_sid_is_undefined",
     },
     {
-        validator(val) {
-            return objHas(val, "ip") && typeof val.ip === "string";
+        validator(val, { validator }) {
+            return (
+                objHas(val, "ip") &&
+                typeof val.ip === "string" &&
+                validator.isIP(val.ip)
+            );
         },
         message: "not-node:identity_field_ip_is_not_valid",
     },

package/src/core/fields/validators/objectId.js

@@ -1,7 +1,11 @@
 module.exports = [
     {
         validator: (val, { validator }) => {
-            return validator.isMongoId(val);
+            return (
+                (typeof val === "string" && validator.isMongoId(val)) ||
+                (typeof val.toString === "function" &&
+                    validator.isMongoId(val.toString()))
+            );
         },
         message: `not-node:value_item_format_is_not_objectId`,
     },

package/src/core/fields/validators/objectId.list.js

@@ -1,14 +1,11 @@
+const objectId = require("./objectId.js");
+
 module.exports = [
     {
         validator: (val) => {
             return Array.isArray(val);
         },
         message: `not-node:value_is_not_array`,
-    },    
-    {
-        validator: (val, { validator }) => {
-            return val.every((itm) => validator.isMongoId(itm));
-        },
-        message: `not-node:value_item_format_is_not_objectId`,
     },
+    ...objectId,
 ];

package/src/core/fields/validators/owner.js

@@ -1,16 +1,8 @@
+const objectId = require("./objectId");
+
 module.exports = [
     {
-        validator(val, { validator }) {
-            if (typeof val === "string") {
-                return validator.isMongoId(val);
-            } else {
-                return (
-                    val &&
-                    typeof val === "object" &&
-                    val.constructor.name === "ObjectId"
-                );
-            }
-        },
+        ...objectId[0],
         message: "not-node:owner_is_not_valid",
     },
 ];

package/src/core/fields/validators/positive.or.zero.number.js

@@ -4,10 +4,10 @@ module.exports = [
             return !isNaN(val);
         },
         message: "not-node:value_is_not_number",
-    },      
+    },
     {
         validator(val) {
-            return (val > 0) && (val === 0);
+            return val >= 0;
         },
         message: "not-node:value_should_be_greater_than_zero",
     },

package/src/fields/index.js

@@ -21,7 +21,7 @@ module.exports.initFileSchemaFromFields = ({
     if (FIELDS && Array.isArray(FIELDS)) {
         const schema = module.exports.createSchemaFromFields(
             app,
-            FIELDS,
+            normalizeFieldsDescriptionsList(FIELDS),
             type,
             moduleName
         );
@@ -30,11 +30,11 @@ module.exports.initFileSchemaFromFields = ({
 };
 
 /**
-fields = [
-  'title', //for standart only name
-  ['titleNonStandart', {component: 'UITextforBlind'}] //arrays of [name, mutation]
-  ['someID', {}, 'ID'],  //copy of standart ID field under name as someID
-]
+fields = [{
+    srcName:string,
+    destName:string,
+    mutation:object,
+}]
 **/
 module.exports.createSchemaFromFields = (
     app,
@@ -43,9 +43,15 @@ module.exports.createSchemaFromFields = (
     moduleName
 ) => {
     let schema = {};
-    fields.forEach((field) => {
+    fields.forEach((fieldDescription) => {
         let [schemaFieldName, schemaFieldValue] =
-            module.exports.initSchemaField(app, field, false, type, moduleName);
+            module.exports.initSchemaField(
+                app,
+                fieldDescription,
+                false,
+                type,
+                moduleName
+            );
         schema[schemaFieldName] = schemaFieldValue;
     });
     return schema;
@@ -53,13 +59,13 @@ module.exports.createSchemaFromFields = (
 
 module.exports.initSchemaField = (
     app,
-    field,
+    fieldDescription,
     resultOnly = true,
     type = "ui",
     moduleName
 ) => {
     //log(field);
-    let { srcName, destName, mutation } = parseFieldDescription(field);
+    let { srcName, destName, mutation } = fieldDescription;
     let proto = findFieldPrototype(app, srcName, type);
     if (!proto) {
         error(
@@ -124,11 +130,24 @@ const findFieldPrototype = (app, name, type) => {
     }
 };
 
+const filterOutPrivateFieldsFromNormalizedFieldDescription = (
+    privateFields
+) => {
+    return ({ destName }) => {
+        return !privateFields.includes(destName);
+    };
+};
+
+const normalizeFieldsDescriptionsList = (list) => {
+    return list.map(parseFieldDescription);
+};
+module.exports.normalizeFieldsDescriptionsList =
+    normalizeFieldsDescriptionsList;
 /**
  * Creates fields UI representation schema from list of fields in DB model
  * and library of fields
  * @param {object} app     notApplication instance
- * @param {object} schema  model db schema
+ * @param {object} rawFieldsList  model db schema
  * @param {Array<string|Array>} rawMutationsList     fields mutations, for little tuning
  * @param {Array<string>} privateFields     fields to omit from result
  * @param {string} moduleName     for detailed reports on issues, in which module and what field is faulty
@@ -137,47 +156,82 @@ const findFieldPrototype = (app, name, type) => {
 
 module.exports.initManifestFields = (
     app, //notApplication
-    schema, //schema of model
+    rawFieldsList, //raw fields list of model
     rawMutationsList = [], //fields mutations
     privateFields = [], //fields to omit
     moduleName //module name for reporting
 ) => {
-    let //shallow copy of array
-        mutationsList = [...rawMutationsList],
-        list = [];
-    if (schema && Object.keys(schema).length > 0) {
-        let rawKeys = Object.keys(schema);
-        rawKeys
-            .filter((key) => !privateFields.includes(key))
-            .forEach((key) => {
-                let mutation = getMutationForField(key, mutationsList);
-                if (mutation.length) {
-                    list.push(mutation);
-                    mutationsList.splice(mutationsList.indexOf(mutation), 1);
+    const //shallow copy of array
+        normalizedMutationsList = [
+            ...normalizeFieldsDescriptionsList(rawMutationsList),
+        ],
+        resultFields = [];
+
+    if (
+        rawFieldsList &&
+        Array.isArray(rawFieldsList) &&
+        rawFieldsList.length > 0
+    ) {
+        const normalizedFieldsList =
+            normalizeFieldsDescriptionsList(rawFieldsList);
+        normalizedFieldsList
+            .filter(
+                filterOutPrivateFieldsFromNormalizedFieldDescription(
+                    privateFields
+                )
+            )
+            .forEach((fieldDescription) => {
+                const { srcName, destName } = fieldDescription;
+                const fieldMutationDescription = getMutationForField(
+                    destName,
+                    normalizedMutationsList
+                );
+                if (fieldMutationDescription) {
+                    resultFields.push({
+                        srcName,
+                        destName,
+                        mutation: fieldMutationDescription.mutation,
+                    });
+                    normalizedMutationsList.splice(
+                        normalizedMutationsList.indexOf(
+                            fieldMutationDescription
+                        ),
+                        1
+                    );
                 } else {
-                    list.push(key);
+                    resultFields.push({
+                        srcName,
+                        destName,
+                        mutation: {},
+                    });
                 }
             });
-        list.push(...mutationsList);
+        resultFields.push(...normalizedMutationsList);
     } else {
-        list = mutationsList;
+        resultFields.push(...normalizedMutationsList);
     }
-    return module.exports.createSchemaFromFields(app, list, "ui", moduleName);
+    return module.exports.createSchemaFromFields(
+        app,
+        resultFields,
+        "ui",
+        moduleName
+    );
 };
 
 /**
  * Returns mutation tuple for a field or false
- * @param {string} name  field name
- * @param {Array} list  fields description lists
- * @return {Array<string|Object>}
+ * @param {string} destName  field name
+ * @param {Array} normalizedFieldsList  fields description lists
+ * @return {Object}
  */
-function getMutationForField(name, list) {
-    for (let item of list) {
-        if (Array.isArray(item) && item[0] === name) {
-            return item;
+function getMutationForField(destName, normalizedFieldsList) {
+    for (let mutationFieldDescription of normalizedFieldsList) {
+        const { destName: mutationDest } = mutationFieldDescription;
+        if (mutationDest === destName) {
+            return mutationFieldDescription;
         }
     }
-    return [];
+    return null;
 }
 module.exports.getMutationForField = getMutationForField;
 

package/src/form/form.js

@@ -3,8 +3,12 @@ const validator = require("validator");
 const notPath = require("not-path");
 const notConfig = require("not-config");
 const FormFabric = require("./fabric");
+const notEnv = require("../env.js");
 const Auth = require("../auth");
-const { createSchemaFromFields } = require("../fields");
+const {
+    createSchemaFromFields,
+    normalizeFieldsDescriptionsList,
+} = require("../fields");
 const notFieldsFilter = require("../fields/filter.js");
 const getApp = require("../getApp.js");
 const {
@@ -36,6 +40,11 @@ const DEFAULT_AFTER_EXTRACT_TRANSFORMERS = [];
 const notAppIdentity = require("../identity/index.js");
 const { ACTION_DATA_TYPES } = require("../const.js");
 
+const DEFAULT_VALIDATOR_ENVS = {
+    validator,
+    env: true, //some env variables for validators
+};
+
 /**
  * Generic form validation class
  * @class Form
@@ -427,15 +436,27 @@ class Form {
      * Returns function that works as a getter for additional environment variables for
      * validators.
      * validationFunction(value, additionalEnvVars = {}){}
+     * @return {function}   getter of validator envs
      **/
     getValidatorEnvGetter() {
-        return () => {
+        //app wide validation envs
+        const appLevelValidationEnvsGetter = notEnv.get("validationEnv");
+        if (typeof appLevelValidationEnvsGetter === "function") {
             //should be sync function
-            return {
-                validator,
-                env: true, //some env variables for validators
+            return () => {
+                return Object.freeze({
+                    ...DEFAULT_VALIDATOR_ENVS,
+                    ...appLevelValidationEnvsGetter(),
+                });
             };
-        };
+        } else {
+            return () => {
+                //should be sync function
+                return Object.freeze({
+                    ...DEFAULT_VALIDATOR_ENVS,
+                });
+            };
+        }
     }
 
     /**
@@ -474,7 +495,7 @@ class Form {
     #createModelSchema(app) {
         return createSchemaFromFields(
             app,
-            this.#PROTO_FIELDS,
+            normalizeFieldsDescriptionsList(this.#PROTO_FIELDS),
             "model",
             this.#FORM_NAME
         );
@@ -743,6 +764,8 @@ class Form {
             case String:
             case Schema.Types.String:
                 return ["xss"];
+            case Schema.Types.Number:
+                return ["parseNumber"];
             default:
                 return [];
         }

package/src/form/transformers/index.js

@@ -6,5 +6,6 @@ module.exports = {
     stringToJSON: require("./stringToJSON.js"),
     xss: require("./xss.js"),
     boolean: require("./boolean.js"),
+    parseNumber: require("./parseNumber.js"),
     __CLEAR__: require("./__CLEAR__.js"),
 };

package/src/form/transformers/parseNumber.js

@@ -0,0 +1,3 @@
+module.exports = (input) => {
+    return ~~input;
+};

package/src/manifest/initializator/manifests.js

@@ -4,34 +4,48 @@ const { initManifestFields } = require("../../fields");
 const { firstLetterToUpper } = require("../../common");
 
 const fieldsIsArray = (mod) => mod && Array.isArray(mod.fields);
-const extractPrivateFields = (mod) =>
-    Array.isArray(mod.privateFields) ? [...mod.privateFields] : [];
+
+
+const getModelName = (routeManifest)=>firstLetterToUpper(routeManifest.model);
 
 module.exports = class notModuleInitializatorManifests {
     static openFile = require;
 
+    static getMutationsFromManifest(nModule,routeName){
+        const routeManifest = nModule.getRouteManifest(routeName);
+        if(fieldsIsArray(routeManifest)){
+            return [...routeManifest.fields];
+        }
+        return [];
+    }
+
+    static extractPrivateFields(routeManifest){
+        const privateFields = [];
+        if (routeManifest.privateFields) {
+            privateFields.push(...(Array.isArray(routeManifest.privateFields) ? [...routeManifest.privateFields] : []));
+            delete routeManifest.privateFields;
+        }
+        return privateFields;
+    }    
+
     static 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
-                    );
-                }
+                const routeManifest = nModule.getRouteManifest(routeName);
+                const rawMutationsList = notModuleInitializatorManifests.getMutationsFromManifest(nModule, routeName);
+                const ModelName = getModelName(routeManifest);
+                const rawFieldsList = nModule.getModelFields(ModelName);
+                const privateFields = notModuleInitializatorManifests.extractPrivateFields(routeManifest);
+
+                routeManifest.fields = initManifestFields(
+                    nModule.getApp(),
+                    rawFieldsList,
+                    rawMutationsList,
+                    privateFields,
+                    moduleName
+                );                
+                
             } catch (e) {
                 error(
                     `Error while initialization of route: ${moduleName}//${routeName}`

package/src/manifest/module.js

@@ -171,6 +171,14 @@ class notModule {
         return null;
     }
 
+    getModelFields(modelName) {
+        const modelFile = this.getModelFile(modelName);
+        if (modelFile && objHas(modelFile, 'FIELDS') && modelFile.FIELDS) {
+            return modelFile.FIELDS;
+        }
+        return null;
+    }
+
     expose(expressApp, moduleName) {
         if (this.manifests && expressApp) {
             notModuleInitializator.exec({ nModule: this });