not-node 6.3.31 → 6.3.33

package/.prettierignore

@@ -0,0 +1 @@
+*.ejs

package/package.json

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

package/src/bootstrap/route.js

@@ -87,8 +87,8 @@ module.exports = ({
 
     const createDefaultForm = function ({ actionName, MODULE_NAME }) {
         const FIELDS = [
-            ["identity", "not-node//requiredObject"],
-            ["data", `${MODULE_NAME}//_data`],
+            ["identity", "not-node//identity"],
+            ["data", `${MODULE_NAME}//_${MODEL_NAME}`],
         ];
         const FORM_NAME = `${MODULE_NAME}:${firstLetterToUpper(
             actionName

package/src/cli/actions/entity.mjs

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { createEntity } from "../lib/entity.mjs";
 import Logger from "../lib/log.mjs";
 import { loadProjectConfig } from "../lib/project.mjs";
+import { getProjectSiteDir } from "../lib/fs.mjs";
 
 export default (program, { CWD }) => {
     program
@@ -10,14 +11,17 @@ export default (program, { CWD }) => {
         .addOption(
             new Option("-v, --verbose").default(false, "extensive output")
         )
+        .addOption(
+            new Option("-d, --dir <dir>").default("", "project site directory")
+        )
         .description("adds entity to existing module of project")
         .action(async (opts) => {
-            console.log(CWD);
-            const siteDir = resolve(CWD, "./site");
+            console.log(CWD, opts);
+            const siteDir = getProjectSiteDir(opts.dir, CWD);
+            console.log("project in", siteDir);
             if (opts.v) {
                 Logger.setSilent(false);
             }
-            console.log("project in", opts.dir);
             const infoFromManifest = await loadProjectConfig(siteDir);
             const modulesDir = resolve(
                 siteDir,

package/src/cli/lib/entity.mjs

@@ -22,6 +22,15 @@ async function renderEntityFiles(module_src_dir, data, config) {
             console.error("No renderer for layer: ", layerName);
         }
     }
+    if (data.layers.includes("controllers") && Renderers.controllersCommons) {
+        Renderers.controllersCommons(
+            resolve(module_src_dir, `./controllers/common`),
+            [data],
+            config,
+            renderFile,
+            Options.PATH_TMPL
+        );
+    }
 }
 
 async function createEntity(modules_dir, config) {
@@ -30,12 +39,13 @@ async function createEntity(modules_dir, config) {
     const moduleDir = resolve(modules_dir, ModuleName);
     const moduleLayers = await Readers.moduleLayers(inquirer);
     const moduleConfig = { ...config, moduleName, ModuleName, moduleLayers };
-    console.log();
+    console.log("moduleConfig", moduleConfig);
     const entityData = await Readers.entityData(
         inquirer,
         moduleConfig,
         moduleConfig.moduleLayers
     );
+    console.log("entityData", entityData);
     await renderEntityFiles(
         resolve(moduleDir, "./src"),
         entityData,

package/src/cli/lib/fs.mjs

@@ -54,6 +54,22 @@ async function copyTmplFile(from, to) {
     }
 }
 
+function getProjectSiteDir(dir, CWD) {
+    if (dir === "") {
+        return resolve(CWD, "./site");
+    } else {
+        if (
+            (dir.indexOf("/") > -1 || dir.indexOf("\\") > -1) &&
+            dir !== "./" &&
+            dir !== ".\\"
+        ) {
+            return dir;
+        } else {
+            return resolve(CWD, dir);
+        }
+    }
+}
+
 async function createDir(dirPath) {
     try {
         //console.log("mkdir", dirPath);
@@ -173,4 +189,5 @@ export {
     buildClientSideScripts,
     installPackages,
     readJSONFile,
+    getProjectSiteDir,
 };

package/src/cli/lib/opts.mjs

@@ -4,14 +4,25 @@ import * as url from "url";
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
 
 class Options {
-    #DEFAULT_SERVER_MODULES_SUB_PATH = "./site/app/server/modules";
+    #DEFAULT_SITE_PATH = "./site";
+    get DEFAULT_SITE_PATH() {
+        return this.#DEFAULT_SITE_PATH;
+    }
+
+    #DEFAULT_SERVER_MODULES_SUB_PATH = "./app/server/modules";
     get DEFAULT_SERVER_MODULES_SUB_PATH() {
-        return this.#DEFAULT_SERVER_MODULES_SUB_PATH;
+        return resolve(
+            this.DEFAULT_SITE_PATH,
+            this.#DEFAULT_SERVER_MODULES_SUB_PATH
+        );
     }
 
-    #DEFAULT_FRONT_MODULES_SUB_PATH = "./site/app/front/src";
+    #DEFAULT_FRONT_MODULES_SUB_PATH = "./app/front/src";
     get DEFAULT_FRONT_MODULES_SUB_PATH() {
-        return this.#DEFAULT_FRONT_MODULES_SUB_PATH;
+        return resolve(
+            this.DEFAULT_SITE_PATH,
+            this.#DEFAULT_FRONT_MODULES_SUB_PATH
+        );
     }
 
     #PATH_TMPL = resolve(__dirname, "../../../tmpl/files");

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,6 +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/core/fields/identity.js

@@ -0,0 +1,12 @@
+const Schema = require("mongoose").Schema;
+
+module.exports = {
+    model: {
+        type: Schema.Types.Mixed,
+        required: true,
+        safe: {
+            update: ["@owner", "root", "admin"],
+            read: ["@owner", "root", "admin"],
+        },
+    },
+};

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

@@ -0,0 +1,64 @@
+const { objHas } = require("../../../common");
+
+module.exports = [
+    {
+        validator(val) {
+            return objHas(val, "root") && typeof val.root == "boolean";
+        },
+        message: "not-node:identity_field_root_is_not_valid",
+    },
+    {
+        validator(val) {
+            return objHas(val, "admin") && typeof val.admin == "boolean";
+        },
+        message: "not-node:identity_field_admin_is_not_valid",
+    },
+    {
+        validator(val) {
+            return objHas(val, "auth") && typeof val.auth == "boolean";
+        },
+        message: "not-node:identity_field_auth_is_not_valid",
+    },
+    {
+        validator(val) {
+            return (
+                objHas(val, "role") &&
+                (typeof val.role === "string" || Array.isArray(val.role))
+            );
+        },
+        message: "not-node:identity_field_role_is_not_valid",
+    },
+    {
+        validator(val) {
+            return (
+                objHas(val, "primaryRole") &&
+                typeof val.primaryRole === "string"
+            );
+        },
+        message: "not-node:identity_field_primaryRole_is_not_valid",
+    },
+    {
+        validator(val) {
+            return objHas(val, "uid");
+        },
+        message: "not-node:identity_field_uid_is_undefined",
+    },
+    {
+        validator(val) {
+            return objHas(val, "sid");
+        },
+        message: "not-node:identity_field_sid_is_undefined",
+    },
+    {
+        validator(val) {
+            return objHas(val, "ip") && typeof val.ip === "string";
+        },
+        message: "not-node:identity_field_ip_is_not_valid",
+    },
+    {
+        validator(val) {
+            return objHas(val, "provider") && typeof val.provider === "string";
+        },
+        message: "not-node:identity_field_provider_is_not_valid",
+    },
+];

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");
 
@@ -24,7 +25,8 @@ const DEFAULT_TRANSFORMERS = require("./transformers");
 
 /**
  * Generic form validation class
- **/
+ * @class Form
+ */
 class Form {
     /**
      * @prop {import('not-validation/src/builder').notValidationSchema} validation schema
@@ -38,10 +40,11 @@ class Form {
      * @prop {string} name of form
      **/
     #FORM_NAME;
+
     #MODEL_NAME;
     #MODULE_NAME;
     #PROTO_FIELDS;
-    #VALIDATOR;
+
     #EXTRACTORS = {
         ...DEFAULT_EXTRACTORS,
     };
@@ -59,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,
@@ -117,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;
@@ -128,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),
+        };
     }
 
     /**
@@ -197,7 +211,7 @@ class Form {
                 throw e;
             } else {
                 throw new notError(
-                    "not-core:form_validation_unknown_error",
+                    "not-node:form_validation_unknown_error",
                     {
                         FORM_NAME: this.#FORM_NAME,
                         PROTO_FIELDS: this.#PROTO_FIELDS,
@@ -323,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,
@@ -423,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"],
@@ -437,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

@@ -1,45 +1,46 @@
-const getIP = require("not-node").Auth.getIP;
 const { MODULE_NAME } = require("../const");
 //DB related validation tools
 const Form = require("not-node").Form;
 //form
-const FIELDS = [
-["activeUser", "not-node//requiredObject"],
-["data", `${MODULE_NAME}//_<%- ModelName %>_data`],
-    ["ip", "not-node//ip"],
-    ];
+const FIELDS = [	
+	["data", `${MODULE_NAME}//_<%- ModelName %>_data`],
+];
 
-    const FORM_NAME = `${MODULE_NAME}:<%- ModelName %>CreateForm`;
+const FORM_NAME = `${MODULE_NAME}:<%- ModelName %>CreateForm`;
 
-        /**
-        *
-        **/
-        module.exports = class <%- ModelName %>CreateForm extends Form {
-            constructor({ app }) {
-            super({ FIELDS, FORM_NAME, app });
-            }
+/**
+ *
+**/
+class <%- ModelName %>CreateForm extends Form {
+	constructor({ app }) {
+		super({ FIELDS, FORM_NAME, app });
+	}
 
-            /**
-            * Extracts data
-            * @param {ExpressRequest} req expressjs request object
-            * @return {Object} forma data
-            **/
-            extract(req) {
-            const ip = getIP(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,
-                                };
-                                }
-                                };
+	/**
+	* 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
+		};	
+	}
+}
+
+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,40 +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`;
 
-        module.exports = 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),
-                                };
-                                }
-                                };
+	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
+			}
+		);
+	}
+};

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

@@ -1,13 +1,10 @@
 const { MODULE_NAME } = require("../const");
 //DB related validation tools
 const Form = require("not-node").Form;
-//not-node
-const getIP = require("not-node").Auth.getIP;
 //form
 const FIELDS = [
-    ["activeUser", "not-node//requiredObject"],
-    ["data", `${MODULE_NAME}//_data`],
-    ["ip", "not-node//ip"],
+    ["identity", "not-node//identity"],
+    ["data", `${MODULE_NAME}//_data`],    
 ];
 
 const FORM_NAME = `${MODULE_NAME}:CreateForm`;

package/tmpl/files/module.server/layers/logics.ejs

@@ -1,73 +1,69 @@
 const MODEL_NAME = "<%- ModelName %>";
-
 const { MODULE_NAME } = require("../const.js");
 const notNode = require("not-node");
-
 const {
-    Log,
-    LogAction,
-    say,
-    phrase,
-    config,
-    getModel,
-    getModelSchema,
-    getLogic,
-    getModelUser,
-} = notNode.Bootstrap.notBootstrapLogic({
-    target: module,
-    MODEL_NAME,
-    MODULE_NAME,
-});
+	Log,
+	LogAction,
+	say,
+	phrase,
+	config,
+	getModel,
+	getModelSchema,
+	getLogic,
+	getModelUser,
+	} = notNode.Bootstrap.notBootstrapLogic({
+		target: module,
+		MODEL_NAME,
+		MODULE_NAME,
+	});
 
 const populateBuilders = {};
 
 const <%- ModelName %>GenericLogic = notNode.Generic.GenericLogic({
-    MODEL_NAME,
-    MODULE_NAME,
-    Log,
-    LogAction,
-    say,
-    phrase,
-    config,
-    getModel,
-    getModelSchema,
-    getLogic,
-    getModelUser,
-    populateBuilders,
-});
-
+        	MODEL_NAME,
+        	MODULE_NAME,
+        	Log,
+	        LogAction,
+        	say,
+	        phrase,
+        	config,
+	        getModel,
+        	getModelSchema,
+	        getLogic,
+        	getModelUser,
+        	populateBuilders,
+	});
+	
 module.exports.thisLogicName = MODEL_NAME;
 
 class <%- ModelName %>Logic extends <%- ModelName %>GenericLogic {
-    <% if(Object.keys(actions).length){ %>
-    <% for(let actionName in actions) { %>
-        static async <%- actionName %>({ targetId, activeUser, ip, root, shouldOwn, data }) {
-            const action = "<%- actionName %>";
-            Log.debug(
-                `${MODULE_NAME}//Logic//${MODEL_NAME}//${action}`,
-                targetId,
-                ip,
-                root
-            );
-            
-            const results = await getModel().<%- actionName %>(
-                targetId,  
-                activeUser._id,              
-                data
-            );           
-
-            LogAction({
-                action,
-                by: activeUser._id,
-                role: activeUser.role,
-                ip,
-                root,
-                shouldOwn,
-            });
-            return results;
-        }
-    <% } %>
-    <% } %>
+	<% if(Object.keys(actions).length){ %>
+	<% for(let actionName in actions) { %>
+	static async <%- actionName %>({ identity, data, targetId, shouldOwn }) {
+		const action = "<%- actionName %>";
+		Log.debug(
+			`${MODULE_NAME}//Logic//${MODEL_NAME}//${action}`,
+			targetId,
+			ip: identity.ip,
+			root: identity.root,
+		);
+		const results = await getModel().<%- actionName %>(			
+			targetId,
+			data,
+			identity
+		);
+		LogAction({
+			action,
+			by: identity.uid,
+			role: identity.role,
+			ip: identity.ip,
+			root: identity.root,
+			shouldOwn,
+		});
+		return results;
+	}
+	<% } %>
+	<% } %>
 }
 
-module.exports[MODEL_NAME] = <%- ModelName %>Logic;
+module.exports[MODEL_NAME] = <%- ModelName %>Logic;

package/tmpl/files/module.server/layers/routes.ejs

@@ -3,45 +3,45 @@ const MODEL_NAME = "<%- ModelName %>";
 const notNode = require("not-node");
 
 const {
-    //	say,
-    //	config,
-    //	Log,
-    before,
-    after,
-    getLogic,
-    //	getModel,
-    //	getModelSchema,
+	//	say,
+	//	config,
+	//	Log,
+	before,
+	after,
+	getLogic,
+	//	getModel,
+	//	getModelSchema,
 } = notNode.Bootstrap.notBootstrapRoute({
-    target: module,
-    MODEL_NAME,
-    MODULE_NAME,
-    defaultAccessRule: true,
+	target: module,
+	MODEL_NAME,
+	MODULE_NAME,
+	defaultAccessRule: true,
 });
 
 const <%- ModelName %>GenericRoute = notNode.Generic.GenericRoute({
-    before, //<-this prepares `prepared`
-    after,
-    getLogic,
+	before, //<-this prepares `prepared`
+	after,
+	getLogic,
 });
 
 class <%- ModelName %>Route extends <%- ModelName %>GenericRoute {
-    <% if(Object.keys(actions).length){ %>
-        <% for(let actionName in actions) { %>
-    static async <%- actionName %>(
-        req, res, next, //standart express routes objects
-        prepared //extracted by `before` if form class exists
-    ) {
-        <% if (layers.includes('forms') && layers.includes('logics')){ %>
-        return await getLogic().<%- actionName %>({ ...prepared });
-        <% } %>
+	<% if(Object.keys(actions).length){ %>
+	<% for(let actionName in actions) { %>
+	static async <%- actionName %>(
+		req, res, next, 	//standart express routes objects
+		prepared 		//extracted by `before` if form class exists
+	) {
+	<% if (layers.includes('forms') && layers.includes('logics')){ %>
+	return await getLogic().<%- actionName %>({ ...prepared });
+	<% } %>
         
-        <% if (layers.includes('forms') && !layers.includes('logics')){ %>
-        return {...prepared};
-        <% } %>
+	<% if (layers.includes('forms') && !layers.includes('logics')){ %>
+	return {...prepared};
+	<% } %>
 
-        <% if (!layers.includes('forms') && layers.includes('logics')){ %>
-        return await getLogic().<%- actionName %>();
-        <% } %>
+	<% if (!layers.includes('forms') && layers.includes('logics')){ %>
+	return await getLogic().<%- actionName %>();
+	<% } %>
     }
     <% } %>   
     <% } %>