not-node 6.3.32 → 6.3.33

package/package.json

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

package/src/cli/readers/entityData.mjs

@@ -5,6 +5,8 @@ import entityLayers from "./entityLayers.mjs";
 import modelValidators from "./modelValidators.mjs";
 import modelVersioning from "./modelVersioning.mjs";
 import modelIncrement from "./modelIncrement.mjs";
+import modelDates from "./modelDates.mjs";
+import modelOwnage from "./modelOwnage.mjs";
 
 const DEFAULT = {
     ModelName: "NewModel",
@@ -37,10 +39,14 @@ export default (inquirer, config, layersList) => {
             result.validators = await modelValidators(inquirer);
             result.versioning = await modelVersioning(inquirer);
             result.increment = await modelIncrement(inquirer, result);
+            result.ownage = await modelOwnage(inquirer);
+            result.dates = await modelDates(inquirer);
         } else {
             result.increment = false;
             result.versioning = false;
             result.validators = true;
+            result.ownage = false;
+            result.dates = false;
         }
         console.log("Entity data", JSON.stringify(result));
         return result;

package/src/cli/readers/modelDates.mjs

@@ -0,0 +1,14 @@
+export default (inquirer) => {
+    return inquirer
+        .prompt([
+            {
+                type: "confirm",
+                name: "enabled",
+                message: "Model should have createdAt and updatedAt fields",
+                default: false,
+            },
+        ])
+        .then((answer) => {
+            return answer.enabled;
+        });
+};

package/src/cli/readers/modelOwnage.mjs

@@ -0,0 +1,15 @@
+export default (inquirer) => {
+    return inquirer
+        .prompt([
+            {
+                type: "confirm",
+                name: "enabled",
+                message:
+                    "Model should support ownage by a specific entity (default: User)?",
+                default: false,
+            },
+        ])
+        .then((answer) => {
+            return answer.enabled;
+        });
+};

package/src/form/form.js

@@ -1,4 +1,5 @@
 const validator = require("validator");
+const notPath = require("not-path");
 const FormFabric = require("./fabric");
 const { createSchemaFromFields } = require("../fields");
 
@@ -61,6 +62,19 @@ class Form {
     #rateLimiterException = FormExceptionTooManyRequests;
     #rateLimiterClientName = InitRateLimiter.DEFAULT_CLIENT;
 
+    /**
+     *
+     * @param {Object} options
+     * @param {Array<string|Array<string>>} options.FIELDS
+     * @param {string} options.FORM_NAME
+     * @param {string} options.MODEL_NAME
+     * @param {string} options.MODULE_NAME
+     * @param {import('../app.js')} options.app
+     * @param {Object.<string, Function>} options.EXTRACTORS
+     * @param {Object.<string, Function>} options.TRANSFORMERS
+     * @param {Object.<string, import('../types.js').notAppFormEnvExtractor>} options.ENV_EXTRACTORS
+     * @param   {import('../types.js').notAppFormRateLimiterOptions}    options.rate
+     */
     constructor({
         FIELDS,
         FORM_NAME,
@@ -119,6 +133,7 @@ class Form {
      **/
     async run(req) {
         let data = await this.extract(req);
+        data = await this.afterExtract(data, req);
         await this.#checkRate(data);
         await this.#_validate(data);
         return data;
@@ -130,13 +145,10 @@ class Form {
      * @return {Promise<import('../types').PreparedData>}        forma data
      **/
     async extract(req) {
-        return this.afterExtract(
-            {
-                ...this.extractRequestEnvs(req),
-                data: this.extractByInstructionsFromRouteActionFields(req),
-            },
-            req
-        );
+        return {
+            ...this.extractRequestEnvs(req),
+            data: this.extractByInstructionsFromRouteActionFields(req),
+        };
     }
 
     /**
@@ -325,76 +337,119 @@ class Form {
         return FormFabric;
     }
 
+    /**
+     *  Object with named extractor functions
+     * @param {Object.<string,function>} extractors
+     */
     #addExtractors(extractors = {}) {
         if (extractors) {
             this.#EXTRACTORS = { ...this.#EXTRACTORS, ...extractors };
         }
     }
 
+    /**
+     * Extracts from express Request object data by inststructions object
+     * @param {import('../types').notNodeExpressRequest} req
+     * @param {import('../types.js').notAppFormProcessingPipe} instructions {fieldName: [extractor, ...transformers]}   extractors and transformers should be string (names of functions from libs) or functions
+     * @returns {Object}
+     */
     extractByInstructions(req, instructions) {
         const results = {};
         for (let fieldName in instructions) {
             const instruction = instructions[fieldName];
             if (Array.isArray(instruction)) {
-                this.#extractByInstructionPipe({
+                this.#extractByInstructionPipe(
                     results,
-                    instructions: instruction,
+                    instruction,
                     fieldName,
-                    req,
-                });
+                    req
+                );
             } else {
-                this.#extractByInstruction({
+                this.#extractByInstruction(
                     results,
                     instruction,
                     fieldName,
-                    req,
-                });
+                    req
+                );
             }
         }
         return results;
     }
 
-    #extractByInstruction({ results, instruction, fieldName, req }) {
+    /**
+     *  Runs one extractor provided as name of extractor from library or as a function.
+     *  Add extracted data to results object.
+     * @param {Object} results
+     * @param {import('../types.js').notAppFormPropertyProcessingPipeInstruction} instruction
+     * @param {string} fieldName    field name, maybe path to sub-object aka data.id
+     * @param {import('../types.js').notNodeExpressRequest} req
+     * @throws {FormExceptionExtractorForFieldIsUndefined}
+     */
+    #extractByInstruction(results, instruction, fieldName, req) {
         if (isFunc(instruction)) {
-            results[fieldName] = instruction(req, fieldName);
+            //using notPath to be able use paths to sub-objects for properties as data.targetId, data.list[0].value etc
+            notPath.set(
+                notPath.PATH_START_OBJECT + fieldName,
+                results,
+                // @ts-ignore
+                instruction(req, fieldName)
+            );
         } else if (typeof instruction == "string") {
             const extractor = this.#EXTRACTORS[instruction];
             if (isFunc(extractor)) {
-                results[fieldName] = extractor(req, fieldName);
+                notPath.set(
+                    notPath.PATH_START_OBJECT + fieldName,
+                    results,
+                    extractor(req, fieldName)
+                );
             } else {
                 throw new FormExceptionExtractorForFieldIsUndefined(fieldName);
             }
         }
     }
 
-    #extractByInstructionPipe({ results, instructions, fieldName, req }) {
+    /**
+     *
+     * @param {Object}       results    resulting object
+     * @param {import('../types.js').notAppFormPropertyProcessingPipe}       instructions
+     * @param {string}  fieldName   field name, maybe path to sub-object aka data.id
+     * @param {import('../types.js').notNodeExpressRequest} req
+     */
+    #extractByInstructionPipe(results, instructions, fieldName, req) {
         if (!instructions || instructions.length === 0) {
             throw new FormExceptionExtractorForFieldIsUndefined(fieldName);
         }
         //
-        this.#extractByInstruction({
-            results,
-            instruction: instructions[0],
-            fieldName,
-            req,
-        });
+        this.#extractByInstruction(results, instructions[0], fieldName, req);
         for (let t = 1; t < instructions.length; t++) {
             const instruction = instructions[t];
-            this.#transformByInstruction({
-                results,
-                instruction,
-                fieldName,
-            });
+            this.#transformByInstruction(results, instruction, fieldName);
         }
     }
 
-    #transformByInstruction({ results, instruction, fieldName }) {
+    /**
+     *
+     * @param {Object} results      resulting object
+     * @param {import('../types.js').notAppFormPropertyProcessingPipeInstruction} instruction
+     * @param {string} fieldName    field name, maybe path to sub-object aka data.id
+     * @throws  {FormExceptionTransformerForFieldIsUndefined}
+     */
+    #transformByInstruction(results, instruction, fieldName) {
         if (isFunc(instruction)) {
-            results[fieldName] = instruction(results[fieldName]);
+            notPath.set(
+                notPath.PATH_START_OBJECT + fieldName,
+                results,
+                // @ts-ignore
+                instruction(results[fieldName])
+            );
         } else if (typeof instruction == "string") {
             const transformer = this.#TRANSFORMERS[instruction];
             if (isFunc(transformer)) {
-                results[fieldName] = transformer(results[fieldName]);
+                notPath.set(
+                    notPath.PATH_START_OBJECT + fieldName,
+                    results,
+                    transformer(results[fieldName])
+                );
             } else {
                 throw new FormExceptionTransformerForFieldIsUndefined(
                     fieldName,
@@ -425,6 +480,13 @@ class Form {
         return [];
     }
 
+    /**
+     *
+     * @param {import('../types.js').notNodeExpressRequest} req
+     * @param {import('../types.js').notAppFormPropertyProcessingPipe} mainInstruction
+     * @param {import('../types.js').notAppFormProcessingPipe} exceptions
+     * @returns {import('../types.js').notAppFormProcessingPipe}
+     */
     createInstructionFromRouteActionFields(
         req,
         mainInstruction = ["fromBody", "xss"],
@@ -439,26 +501,32 @@ class Form {
                 result[fieldName] = mainInstruction;
             }
         });
+        // @ts-ignore
         return result;
     }
 
     /**
-     *
-     * @param {import('express').Request}   req
-     * @param {Array<string>}               mainInstruction
-     * @param {object}                      exceptions
-     * @returns
+     *  Creates object {[fieldName]: Array[extractor:string|function, ...transformers:Array<string|function>]}
+     * @param {import('../types.js').notNodeExpressRequest}   req       express request with notRouteData property
+     * @param {import('../types.js').notAppFormPropertyProcessingPipe}               mainInstruction             what is a common pipe to apply to an property [extractor, ...transformers]
+     * @param {import('../types.js').notAppFormProcessingPipe}                      exceptions                  what shouldn't be treated as common and have own pipes {fieldName:string: [extractor, ...transformers]}
+     * @param {import('../types.js').notAppFormProcessingPipe}                      additional
+     * @returns {object}
      */
     extractByInstructionsFromRouteActionFields(
         req,
         mainInstruction = ["fromBody", "xss"],
-        exceptions = {}
+        exceptions = {},
+        additional = {}
     ) {
-        const instructions = this.createInstructionFromRouteActionFields(
-            req,
-            mainInstruction,
-            exceptions
-        );
+        const instructions = {
+            ...this.createInstructionFromRouteActionFields(
+                req,
+                mainInstruction,
+                exceptions
+            ),
+            ...additional,
+        };
         return this.extractByInstructions(req, instructions);
     }
 

package/src/types.js

@@ -95,4 +95,32 @@
  * @property    {string}        provider    //provider class name
  */
 
+/**
+ * @typedef     {string|function}    notAppFormPropertyProcessingPipeInstruction
+ */
+
+/**
+ * @typedef     {Array<notAppFormPropertyProcessingPipeInstruction>}    notAppFormPropertyProcessingPipe
+ */
+
+/**
+ * @typedef     {Object.<string, notAppFormPropertyProcessingPipe>}    notAppFormProcessingPipe
+ */
+
+/**
+ * @typedef     {object}    notAppFormEnvExtractor
+ * @property    {string}    name
+ * @property    {any}       value
+ */
+
+/**
+ * @typedef     {object}    notAppFormRateLimiterOptions
+ * @property    {object}    [options]
+ * @property    {string}    [options.keyPrefix]
+ * @property    {number}    [options.points]
+ * @property    {number}    [options.duration]
+ * @property    {object}    [exception]
+ * @property    {function}  [idGetter]
+ * @property    {string}    [client]
+ */
 module.exports = {};

package/tmpl/files/module.server/layers/forms/_data.ejs

@@ -4,32 +4,36 @@ const Form = require("not-node").Form;
 
 const FIELDS = [
 <% if (fields && Array.isArray(fields)) { %>
-    <% for(let field of fields){ %>
-        <%- `"${field}",` -%>
-            <% } %>
-                <% } %>
-                    ["owner", "not-node//owner"],
-                    ["ownerModel", "not-node//ownerModel"],
-                    ];
-
-                    const FORM_NAME = `${MODULE_NAME}:_<%- ModelName %>DataForm`;
-
-
-                        //const validateTitle = require("./validators/title.js");
-
-                        module.exports = class _DataForm extends Form {
-                        constructor({ app }) {
-                        super({ FIELDS, FORM_NAME, app });
-                        }
-
-                        extract(data) {
-                        return data;
-                        }
-
-                        getFormValidationRules() {
-                        return [
-                        //add validators here
-                        //validateTitle,
-                        ];
-                        }
-                        };
+<% for(let field of fields){ %>
+	<%- `"${field}",` -%>
+<% } %>
+<% } %>
+<% if (ownage) { %>
+	["owner", "not-node//owner"],
+	["ownerModel", "not-node//ownerModel"],
+<% } %>
+];
+
+const FORM_NAME = `${MODULE_NAME}:_<%- ModelName %>DataForm`;
+
+//const validateTitle = require("./validators/title.js");
+class _<%- ModelName %>_DataForm extends Form {
+	constructor({ app }) {
+		super({ FIELDS, FORM_NAME, app });
+	}
+
+	//could do something with data, before validation
+	async extract(data) {
+		return data;
+	}
+	
+	//fields validators are loaded automatically, form validators should be returned from here as an array
+	getFormValidationRules() {
+		return [
+			//add validators here
+			//validateTitle,
+		];
+	}
+}
+
+module.exports = _<%- ModelName %>_DataForm;

package/tmpl/files/module.server/layers/forms/create.ejs

@@ -2,42 +2,45 @@ const { MODULE_NAME } = require("../const");
 //DB related validation tools
 const Form = require("not-node").Form;
 //form
+const FIELDS = [	
+	["data", `${MODULE_NAME}//_<%- ModelName %>_data`],
+];
 
-const FIELDS = [
-["identity", "not-node//identity"],
-["data", `${MODULE_NAME}//_<%- ModelName %>_data`],
-    ];
+const FORM_NAME = `${MODULE_NAME}:<%- ModelName %>CreateForm`;
 
-    const FORM_NAME = `${MODULE_NAME}:<%- ModelName %>CreateForm`;
+/**
+ *
+**/
+class <%- ModelName %>CreateForm extends Form {
+	constructor({ app }) {
+		super({ FIELDS, FORM_NAME, app });
+	}
 
-        /**
-        *
-        **/
-        module.exports = class <%- ModelName %>CreateForm extends Form {
-            constructor({ app }) {
-            super({ FIELDS, FORM_NAME, app });
-            }
+	/**
+	* Extracts data
+	* @param {import('not-node/src/types.js').notNodeExpressRequest} req expressjs request object
+	* @return {Object} forma data
+	**/
+	extract(req) {		
+		const data = this.extractByInstructionsFromRouteActionFields(
+			req,			//request object 
+			["fromBody", "xss"], 	//extraction common pipe [extractor, ...transformers]
+			{}			//exceptions {fieldName: [extractor, ...transformers],...}
+		);
+		//contains targetId, identity and some more. look full list in not-node/src/form/env_extractors/index.js
+		const envs = this.extractRequestEnvs(req);
+		<% if ( ownage ) { %>
+		//admin could change ownage for others hardwired
+		if (!identity.admin) {
+			data.owner = identity.uid;
+			data.ownerModel = 'User';
+		}
+		<% } %>
+		return	{
+			...envs,
+			data
+		};	
+	}
+}
 
-            /**
-            * Extracts data
-            * @param {import('not-node/src/types.js').notNodeExpressRequest} req expressjs request object
-            * @return {Object} forma data
-            **/
-            extract(req) {
-            const instructions = {
-            <% if (fields && Array.isArray(fields)) { %>
-                <% for(let field of fields){ %>
-                    <%- field+': "fromBody" ,' -%>
-                        <% } %>
-                            <% } %>
-                                owner: "activeUserId",
-                                ownerModel: "activeUserModelName",
-                                };
-                                const data = this.extractByInstructions(req, instructions);
-                                return {
-                                activeUser: req.user,
-                                ip,
-                                data,
-                                };
-                                }
-                                };
+module.exports = <%- ModelName %>CreateForm;

package/tmpl/files/module.server/layers/forms/listAll.ejs

@@ -5,4 +5,4 @@ module.exports = notNode.Generic.GenericListAndCountForm({
 MODULE_NAME,
 MODEL_NAME: "<%- ModelName %>",
     actionName: "listAll",
-    });
+    });

package/tmpl/files/module.server/layers/forms/listAndCount.ejs

@@ -5,4 +5,4 @@ module.exports = notNode.Generic.GenericListAndCountForm({
 MODULE_NAME,
 MODEL_NAME: "<%- ModelName %>",
     actionName: "listAndCount",
-    });
+    });

package/tmpl/files/module.server/layers/forms/update.ejs

@@ -1,41 +1,33 @@
 const { MODULE_NAME } = require("../const");
 const Form = require("not-node").Form;
-const getIP = require("not-node").Auth.getIP;
 
 const FIELDS = [
-["targetId", { required: true }, "not-node//objectId"],
-["activeUser", "not-node//requiredObject"],
-["data", `${MODULE_NAME}//_<%- ModelName %>_data`], //sub forms validators should start with underscore
-    ["ip", "not-node//ip"],
-    ];
-    const FORM_NAME = `${MODULE_NAME}:<%- ModelName %>UpdateForm`;
+	["targetId", { required: true }, "not-node//objectId"],
+	["identity", "not-node//identity"],
+	["data", `${MODULE_NAME}//_<%- ModelName %>_data`], //sub forms validators should start with underscore
+];
+const FORM_NAME = `${MODULE_NAME}:<%- ModelName %>UpdateForm`;
 
-        class <%- ModelName %>UpdateForm extends Form {
-            constructor({ app }) {
-            super({ FIELDS, FORM_NAME, app });
-            }
+class <%- ModelName %>UpdateForm extends Form {
+	constructor({ app }) {
+		super({ FIELDS, FORM_NAME, app });
+	}
 
-            extract(req) {
-            const instructions = {
-            <% if (fields && Array.isArray(fields)) { %>
-                <% for(let field of fields){ %>
-                    <%- field+': "fromBody" ,' -%>
-                        <% } %>
-                            <% } %>
-                                owner: "fromBody",
-                                ownerModel: "fromBody",
-                                };
-                                const data = this.extractByInstructions(req, instructions);
-                                if (!req.user.isRoot() && !req.user.isAdmin()) {
-                                data.owner = req.user._id;
-                                data.ownerModel = "User";
-                                }
-                                return {
-                                targetId: req.params._id.toString(),
-                                activeUser: req.user,
-                                data,
-                                ip: getIP(req),
-                                };
-                                }
-                                }
-                                module.exports = <%- ModelName %>UpdateForm;
+	extract(req) {
+		const data = this.extractByInstructionsFromRouteActionFields(req, ["fromBody", "xss"], {});
+		const envs = this.extractRequestEnvs(req);
+		<% if ( ownage ) { %>
+		//admin could change ownage for others hardwired
+		if (!identity.admin) {
+			data.owner && delete data.owner;
+			data.ownerModel && delete data.ownerModel;
+		}
+		<% } %>	
+		return {
+			...envs, //contains targetId, identity and some more. look list in not-node/src/form/env_extractors/index.js
+			data,
+		};
+	}
+}
+
+module.exports = <%- ModelName %>UpdateForm;

package/tmpl/files/module.server/layers/forms/validator.ejs

@@ -1,32 +1,37 @@
 const notNode = require("not-node");
 const { notValidationError } = require("not-error");
 
+/**
+* async validation function, should throw notValidationError if validation failed
+* @param {object}	data			form data object
+* @param {object}	validationEnvs		special object that provides access to injected on project level resources and libraries
+*/
 module.exports = async (
 /**
 * Values to validate in form
 */
-{owner, ownerModel, vals, to , validate },
+	{owner, ownerModel, vals, to , validate },
 /**
 * special container to pass around global validation libs, CONSTs and inject other entities
 */
-validationEnvs
+	validationEnvs
 ) => {
-//some preparations
-if (
-//vals checks
-) {
-throw new notValidationError(
-"<%- ModuleName %>:validation_error",
-    {
-    //vals: ["%- ModuleName %>:vals_should_be_valid"],
-    },
-    undefined, //no source error, its custom exception
-    {
-    //information
-    //vals,
-    //owner,
-    //ownerModel
-    }
-    );
-    }
-    };
+	//some preparations
+	if (
+		//vals checks
+	) {
+		throw new notValidationError(			
+			"<%- ModuleName %>:<%- modelName %>_validation_error",
+			{
+				//vals: ["%- ModuleName %>:vals_should_be_valid"],
+			},
+			undefined, //no source error, its custom exception
+			{
+				//information
+				//vals,
+				//owner,
+				//ownerModel
+			}
+		);
+	}
+};