not-node 6.3.32 → 6.3.34

package/package.json

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

package/src/cli/actions/module.front.mjs

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import Logger from "../lib/log.mjs";
 import { createFrontModule } from "../lib/module.front.mjs";
 import { loadProjectConfig } from "../lib/project.mjs";
+import { getProjectSiteDir } from "../lib/fs.mjs";
 import Options from "../lib/opts.mjs";
 
 export default (program, { CWD }) => {
@@ -11,14 +12,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 new front module to existing project")
         .action(async (opts) => {
             console.log(CWD);
-            const siteDir = resolve(CWD, "./site");
+            const siteDir = getProjectSiteDir(opts.dir, CWD);
             if (opts.v) {
                 Logger.setSilent(false);
             }
-            console.log("project in", opts.dir);
+            console.log("project in", siteDir);
             const infoFromManifest = await loadProjectConfig(siteDir);
             const modulesDir = resolve(
                 siteDir,

package/src/cli/actions/module.server.mjs

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import Logger from "../lib/log.mjs";
 import { createServerModule } from "../lib/module.server.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 new server module to existing project")
         .action(async (opts) => {
             console.log(CWD);
-            const siteDir = resolve(CWD, "./site");
+            const siteDir = getProjectSiteDir(opts.dir, CWD);
             if (opts.v) {
                 Logger.setSilent(false);
             }
-            console.log("project in", opts.dir);
+            console.log("project in", siteDir);
             const infoFromManifest = await loadProjectConfig(siteDir);
             const modulesDir = resolve(
                 siteDir,

package/src/cli/readers/ModuleName.mjs

@@ -5,7 +5,7 @@ export default (inquirer) => {
                 type: "input",
                 name: "name",
                 message: "Module Name",
-                default: "notNodeModule",
+                default: "not-my-module",
             },
         ])
         .then((answers) => {

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 {Promise<Object>} form data
+	**/
+	async 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;
+	async 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/models.ejs

@@ -22,10 +22,14 @@ const FIELDS = [
     "<%- field %>",
     <% } %>
     <% } %>
+    <% if (ownage){ %>
     ["owner", "not-node//owner"],
     ["ownerModel", "not-node//ownerModel"],
+    <% } %>
+    <% if (dates){ %>
     ["createdAt", "not-node//createdAt"],
     ["updatedAt", "not-node//updatedAt"],
+    <% } %>
 ];
 
 module.exports.FIELDS = FIELDS;
@@ -45,16 +49,21 @@ module.exports.thisVirtuals = {
 
 module.exports.thisPre = {
     updateOne: async () => {
+    	<% if (dates){ %>this.updatedAt = new Date();<% } %>
         //	console.debug('model pre updateOne');
     },
-    insert: async () => {
+    insert: async () => {    
         //console.log('model pre insert');
+        <% if (dates){ %>this.updatedAt = new Date();
+        this.createdAt = new Date();<% } %>
     },
     save: async () => {
         //console.log('model pre save');
+        <% if (dates){ %>this.updatedAt = new Date();<% } %>
     },
     update: async () => {
         //console.log('model pre update' );
+        <% if (dates){ %>this.updatedAt = new Date();<% } %>
     },
 };
 

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

@@ -1,220 +1,224 @@
 const ACTION_SIGNATURES = require('not-node/src/auth/const').ACTION_SIGNATURES;
 const FIELDS = [
     ["_id", "not-node//_id"],
+    <% if (increment){ %>
     ["<%- modelName %>ID", "not-node//ID"],
+    <% } %>
     <% if (fields && Array.isArray(fields)) { %>
     <% for(let field of fields){ %>
     "<%- field %>",
     <% } %>
     <% } %>
+    <% if (ownage){ %>
     ["owner", "not-node//owner"],
     ["ownerModel", "not-node//ownerModel"],
+    <% } %>
+    <% if (dates){ %>
     ["createdAt", "not-node//createdAt"],
     ["updatedAt", "not-node//updatedAt"],
+    <% } %>
 ];
 
 const actionNamePath = "/:actionName";
 const idActionPath = "/:record[_id]/:actionName";
 
 module.exports = {
-    model: "<%- modelName %>",
-    url: "/api/:modelName",
-    fields: FIELDS,
-    privateFields: [],
-    actions: {                        
-        <% if (Object.hasOwn(actions, 'create')){ %>
-        create: {
-            method: "put",
-            actionSignature: ACTION_SIGNATURES.CREATE,
-            title: "<%- ModuleName %>:form_title_create",
-            description: "<%- ModuleName %>:form_description_create",
-            rules: [
-                {
-                    auth: true,
-                    root: true,
-                    fields: [<%- fields.map((entry) => `"${entry}"`).join(',')  %>,"owner"],
-                },
-                {
-                    auth: true,
-                    role: ["client", "confirmed"],
-                    fields: ["title"],
-                },
-            ],
-            data: ["record"],
-            postFix: actionNamePath,
-        },
-        <% } %>
-        <% if (Object.hasOwn(actions,'get')){ %>
-        get: {
-            method: "get",
-            actionSignature: ACTION_SIGNATURES.READ,
-            title: "<%- ModuleName %>:form_title_details",
-            description: "<%- ModuleName %>:form_description_details",
-            rules: [
-                {
-                    auth: true,
-                    root: true,
-                    fields: [
-                        "_id",
-                        "<%- modelName %>ID",
-                        <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
-                        "owner",
-                        "ownerModel",
-                        "createdAt",
-                        "updatedAt",
-                    ],
-                },
-                {
-                    auth: true,
-                    role: ["client", "confirmed"],
-                    fields: [
-                        "_id",
-                        "<%- modelName %>ID",
-                        <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
-                        "createdAt",
-                        "updatedAt",
-                    ],
-                },
-            ],
-            postFix: idActionPath,
-        },
-        <% } %>
-        <% if (Object.hasOwn(actions,'getRaw')){ %>
-        getRaw: {
-            method: "get",
-            actionSignature: ACTION_SIGNATURES.READ,
-            title: "<%- ModuleName %>:form_title_details",
-            description: "<%- ModuleName %>:form_description_details",
-            rules: [
-                {
-                    auth: true,
-                    root: true,
-                    fields: [
-                        "_id",
-                        "<%- modelName %>ID",
-                        <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
-                        "owner",
-                        "ownerModel",
-                        "createdAt",
-                        "updatedAt",
-                    ],
-                },
-                {
-                    auth: true,
-                    role: "admin",
-                    fields: [
-                        "_id",
-                        "<%- modelName %>ID",
-                        <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
-                        "owner",
-                        "ownerModel",
-                        "createdAt",
-                        "updatedAt",
-                    ],
-                },
-                {
-                    auth: true,
-                    role: ["client", "confirmed"],
-                    fields: [
-                        "<%- modelName %>ID",
-                        <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
-                        "createdAt",
-                        "updatedAt",
-                    ],
-                },
-            ],
-            postFix: idActionPath,
-        },
-        <% } %>
-        <% if (Object.hasOwn(actions,'update')){ %>
-        update: {
-            title: "<%- ModuleName %>:form_title_update",
-            actionSignature: ACTION_SIGNATURES.UPDATE,
-            description: "<%- ModuleName %>:form_description_update",
-            method: "post",
-            rules: [
-                {
-                    auth: true,
-                    root: true,
-                    fields: [<%- fields.map((entry) => `"${entry}"`).join(',')  %>, "owner", "ownerModel"],
-                },
-                {
-                    auth: true,
-                    role: ["client", "confirmed"],
-                    fields: [<%- fields.map((entry) => `"${entry}"`).join(',')  %>],
-                },
-            ],
-            data: ["record"],
-            postFix: idActionPath,
-        },        
-        <% } %>
-        <% if (Object.hasOwn(actions,'delete')){ %>
-        delete: {
-            actionSignature: ACTION_SIGNATURES.DELETE,
-            title: "<%- ModuleName %>:form_title_delete",
-            description: "<%- ModuleName %>:form_description_delete",
-            method: "delete",
-            rules: [
-                {
-                    auth: true,
-                    root: true,
-                },
-                {
-                    auth: true,
-                    role: ["client", "confirmed"],
-                },
-            ],
-            data: ["record"],
-            postFix: idActionPath,
-        },
-        <% } %>
-        <% if (Object.hasOwn(actions,'listAndCount')){ %>
-        listAndCount: {
-            method: "get",
-            actionSignature: ACTION_SIGNATURES.READ,
-            data: ["pager", "sorter", "filter", "search"],
-            rules: [
-                {
-                    auth: true,
-                    root: true,
-                },
-                {
-                    auth: true,
-                    role: "admin",
-                },
-                {
-                    auth: true,
-                    role: ["client", "confirmed"],
-                },
-            ],
-            postFix: actionNamePath,
-        },
-        <% } %>
-        <% if (Object.hasOwn(actions,'listAll')){ %>
-        listAll: {
-            method: "get",
-            actionSignature: ACTION_SIGNATURES.READ,
-            data: ["record", "sorter"],
-            fields: [
-            <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
-                "createdAt",
-                "updatedAt",
-            ],
-            postFix: actionNamePath,
-            rules: [
-                {
-                    root: true,
-                },
-                {
-                    auth: true,
-                    role: ["manager"],
-                },
-                {
-                    auth: true,
-                },
-            ],
-        },
-        <% } %>
-    },
+	model: "<%- modelName %>",
+	url: "/api/:modelName",
+	fields: FIELDS,
+	privateFields: [],
+	actions: {
+		<% if (Object.hasOwn(actions, 'create')){ %>
+		create: {
+			method: "put",
+			actionSignature: ACTION_SIGNATURES.CREATE,
+			title: "<%- ModuleName %>:form_title_create",
+			description: "<%- ModuleName %>:form_description_create",
+			rules: [
+				{
+					auth: true,
+					root: true,
+					fields: [
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (ownage){ %>"owner",<% } %>
+					],
+				},
+				{
+					auth: true,
+					role: ["client", "confirmed"],
+					fields: ["title"],
+				},
+			],
+			data: ["record"],
+			postFix: actionNamePath,
+		},
+		<% } %>
+		<% if (Object.hasOwn(actions,'get')){ %>
+		get: {
+			method: "get",
+			actionSignature: ACTION_SIGNATURES.READ,
+			title: "<%- ModuleName %>:form_title_details",
+			description: "<%- ModuleName %>:form_description_details",
+			rules: [
+				{
+					auth: true,
+					root: true,
+					fields: [
+						"_id",
+						<% if (increment){ %>"<%- modelName %>ID",<% } %>
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (ownage){ %>"owner","ownerModel",<% } %>
+						<% if (dates){ %>"createdAt","updatedAt",<% } %>
+					],
+				},
+				{
+					auth: true,
+					role: ["client", "confirmed"],
+					fields: [
+						"_id",
+						<% if (increment){ %>"<%- modelName %>ID",<% } %>
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (dates){ %>"createdAt","updatedAt",<% } %>
+					],
+				},
+			],
+			postFix: idActionPath,
+		},
+		<% } %>
+		<% if (Object.hasOwn(actions,'getRaw')){ %>
+		getRaw: {
+			method: "get",
+			actionSignature: ACTION_SIGNATURES.READ,
+			title: "<%- ModuleName %>:form_title_details",
+			description: "<%- ModuleName %>:form_description_details",
+			rules: [
+				{
+					auth: true,
+					root: true,
+					fields: [
+						"_id",
+						<% if (increment){ %>"<%- modelName %>ID",<% } %>
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (ownage){ %>"owner","ownerModel",<% } %>
+						<% if (dates){ %>"createdAt","updatedAt",<% } %>
+					],
+				},
+				{
+					auth: true,
+					role: "admin",
+					fields: [
+						"_id",
+						<% if (increment){ %>"<%- modelName %>ID",<% } %>
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (ownage){ %>"owner","ownerModel",<% } %>
+						<% if (dates){ %>"createdAt","updatedAt",<% } %>
+					],
+				},
+				{
+					auth: true,
+					role: ["client", "confirmed"],
+					fields: [
+						<% if (increment){ %>"<%- modelName %>ID",<% } %>
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (dates){ %>"createdAt","updatedAt",<% } %>
+					],
+				},
+			],
+			postFix: idActionPath,
+		},
+		<% } %>
+		<% if (Object.hasOwn(actions,'update')){ %>
+		update: {
+			title: "<%- ModuleName %>:form_title_update",
+			actionSignature: ACTION_SIGNATURES.UPDATE,
+			description: "<%- ModuleName %>:form_description_update",
+			method: "post",
+			rules: [
+				{
+					auth: true,
+					root: true,
+					fields: [
+						<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+						<% if (ownage){ %>"owner", "ownerModel",<% } %>
+					],
+				},
+				{
+					auth: true,
+					role: ["client", "confirmed"],
+					fields: [<%- fields.map((entry) => `"${entry}"`).join(',')  %>],
+				},
+			],
+			data: ["record"],
+			postFix: idActionPath,
+		}, 
+		<% } %>
+		<% if (Object.hasOwn(actions,'delete')){ %>
+		delete: {
+			actionSignature: ACTION_SIGNATURES.DELETE,
+			title: "<%- ModuleName %>:form_title_delete",
+			description: "<%- ModuleName %>:form_description_delete",
+			method: "delete",
+			rules: [
+				{
+					auth: true,
+					root: true,
+				},
+				{
+					auth: true,
+					role: ["client", "confirmed"],
+				},
+			],
+			data: ["record"],
+			postFix: idActionPath,
+		},
+		<% } %>
+		<% if (Object.hasOwn(actions,'listAndCount')){ %>
+		listAndCount: {
+			method: "get",
+			actionSignature: ACTION_SIGNATURES.READ,
+			data: ["pager", "sorter", "filter", "search"],
+			rules: [
+				{
+					auth: true,
+					root: true,
+				},
+				{
+					auth: true,
+					role: "admin",
+				},
+				{
+					auth: true,
+					role: ["client", "confirmed"],
+				},
+			],
+			postFix: actionNamePath,
+		},
+		<% } %>
+		<% if (Object.hasOwn(actions,'listAll')){ %>
+		listAll: {
+			method: "get",
+			actionSignature: ACTION_SIGNATURES.READ,
+			data: ["record", "sorter"],
+			fields: [
+				<%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+				<% if (dates){ %>"createdAt","updatedAt",<% } %>
+			],
+			postFix: actionNamePath,
+			rules: [
+				{
+					root: true,
+				},
+				{
+					auth: true,
+					role: ["manager"],
+				},
+				{
+					auth: true,
+				},
+			],
+		},
+		<% } %>
+	},
 };
 
+