not-node 6.2.20 → 6.2.22

package/package.json

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

package/src/manifest/registrator/fields.js

@@ -49,6 +49,16 @@ module.exports = class notModuleRegistratorFields {
         log(`${MODULE_NAME}//${name} with ${fieldValidatorsCount} validators`);
     }
 
+    findValidatorsFile(name, fromPath, possible_extensions = [".js", ".cjs"]) {
+        for (let ext of possible_extensions) {
+            const validatorName = path.join(fromPath, "validators", name + ext);
+            if (tryFile(validatorName)) {
+                return validatorName;
+            }
+        }
+        return 0;
+    }
+
     /**
      *
      **/
@@ -57,9 +67,9 @@ module.exports = class notModuleRegistratorFields {
             return;
         }
         //load validators
-        const validatorName = path.join(fromPath, "validators", name + ".js");
-        if (!tryFile(validatorName)) {
-            return 0;
+        const validatorName = this.findValidatorsFile(name, fromPath);
+        if (!validatorName) {
+            return;
         }
         const validators = notModuleRegistratorFields.openFile(validatorName);
         //inject into field.model

package/src/manifest/registrator/routes.js

@@ -12,21 +12,21 @@ const notModuleRegistratorRoutesWS = require("./routes.ws");
  * @constant
  * @type {string}
  */
-const DEFAULT_MANIFEST_FILE_ENDING = ".manifest.js";
+const DEFAULT_MANIFEST_FILE_ENDINGS = [".manifest.js", ".manifest.cjs"];
 
 /**
  * Routes collection files ending
  * @constant
  * @type {string}
  */
-const DEFAULT_ROUTES_FILE_ENDING = ".js";
+const DEFAULT_ROUTES_FILE_ENDINGS = [".js", ".cjs"];
 
 /**
  * WS End-points collection files ending
  * @constant
  * @type {string}
  */
-const DEFAULT_WS_ROUTES_FILE_ENDING = ".ws.js";
+const DEFAULT_WS_ROUTES_FILE_ENDINGS = [".ws.js", ".ws.cjs"];
 
 /**
  * List of methods to be binded from notApp to routes and WS end-points
@@ -78,10 +78,23 @@ module.exports = class notModuleRegistratorRoutes {
         );
     }
 
+    getFileBasename(file, possible_extensions = []) {
+        for (let ext of possible_extensions) {
+            if (file.indexOf(ext) !== -1) {
+                return file.substr(0, file.indexOf(ext));
+            }
+        }
+        return false;
+    }
+
     findOne({ nModule, srcDir, file }) {
         try {
             //если имя похоже на название манифеста
-            if (file.indexOf(DEFAULT_MANIFEST_FILE_ENDING) === -1) {
+            const routeBasename = this.getFileBasename(
+                file,
+                DEFAULT_MANIFEST_FILE_ENDINGS
+            );
+            if (!routeBasename) {
                 return false;
             }
             const routeManifest =
@@ -93,10 +106,6 @@ module.exports = class notModuleRegistratorRoutes {
             if (!routeManifest) {
                 return false;
             }
-            const routeBasename = file.substr(
-                0,
-                file.indexOf(DEFAULT_MANIFEST_FILE_ENDING)
-            );
             //ищем end-points
             const route = notModuleRegistratorRoutes.tryRouteFile({
                 srcDir,
@@ -124,20 +133,18 @@ module.exports = class notModuleRegistratorRoutes {
     }
 
     static tryRouteFile({ srcDir, routeBasename }) {
-        const routePath = path.join(
-            srcDir,
-            routeBasename + DEFAULT_ROUTES_FILE_ENDING
-        );
-        if (tryFile(routePath)) {
-            const route = notModuleRegistratorRoutes.openFile(routePath);
-            route.filename = routePath;
-            if (!route.thisRouteName) {
-                route.thisRouteName = routeBasename;
+        for (let ext of DEFAULT_ROUTES_FILE_ENDINGS) {
+            const routePath = path.join(srcDir, routeBasename + ext);
+            if (tryFile(routePath)) {
+                const route = notModuleRegistratorRoutes.openFile(routePath);
+                route.filename = routePath;
+                if (!route.thisRouteName) {
+                    route.thisRouteName = routeBasename;
+                }
+                return route;
             }
-            return route;
-        } else {
-            return false;
         }
+        return false;
     }
 
     static tryRouteManifestFile({ srcDir, file }) {
@@ -150,19 +157,18 @@ module.exports = class notModuleRegistratorRoutes {
     }
 
     static tryWSRouteFile({ srcDir, routeBasename }) {
-        const routeWSPath = path.join(
-            srcDir,
-            routeBasename + DEFAULT_WS_ROUTES_FILE_ENDING
-        );
-        if (tryFile(routeWSPath)) {
-            const wsRoute = notModuleRegistratorRoutes.openFile(routeWSPath);
-            if (!wsRoute.thisRouteName) {
-                wsRoute.thisRouteName = routeBasename;
+        for (let ext of DEFAULT_WS_ROUTES_FILE_ENDINGS) {
+            const routeWSPath = path.join(srcDir, routeBasename + ext);
+            if (tryFile(routeWSPath)) {
+                const wsRoute =
+                    notModuleRegistratorRoutes.openFile(routeWSPath);
+                if (!wsRoute.thisRouteName) {
+                    wsRoute.thisRouteName = routeBasename;
+                }
+                return wsRoute;
             }
-            return wsRoute;
-        } else {
-            return false;
         }
+        return false;
     }
 
     registerManifestAndRoutes({

package/src/manifest/route.js

@@ -191,15 +191,17 @@ class notRoute {
                 prepared,
             ]);
             //filter result IF actionData.return specified
-            if (typeof result.toObject === "function") {
-                result = result.toObject();
-            }
-            if (Array.isArray(result)) {
-                result = result.map((itm) =>
-                    itm.toObject ? itm.toObject() : itm
-                );
+            if (typeof result !== "undefined" && result) {
+                if (typeof result.toObject === "function") {
+                    result = result.toObject();
+                }
+                if (Array.isArray(result)) {
+                    result = result.map((itm) =>
+                        itm.toObject ? itm.toObject() : itm
+                    );
+                }
+                notManifestRouteResultFilter.filter(req.notRouteData, result);
             }
-            notManifestRouteResultFilter.filter(req.notRouteData, result);
             //run after with results, continue without waiting when it finished
             return this.executeFunction(modRoute, CONST_AFTER_ACTION, [
                 req,

package/test/module/routes.js

@@ -1,288 +1,330 @@
-const path = require('path');
-const notModuleRegistratorRoutes = require('../../src/manifest/registrator/routes');
+const path = require("path");
+const notModuleRegistratorRoutes = require("../../src/manifest/registrator/routes");
 
-module.exports = ({
-  expect
-}) => {
-  describe('notModuleRegistratorRoutes', () => {
-    const routesPath = path.join(__dirname, '../testies/module/routes');
-    describe('getPath', () => {
-      it('module paths(routes)', function() {
-        const testPath = 'path_to_routes';
-        const ctx = {
-          module: {
-            paths: {
-              routes: testPath
-            }
-          }
-        };
-        const pathTo = notModuleRegistratorRoutes.getPath(ctx);
-        expect(pathTo).to.be.equal(testPath);
-      });
-    });
-
-    describe('run', () => {
-      it('path to routes is not defined', function() {
-        const ctx = {
-          findAll(){}
-        };
-        const param = {
-          nModule:{
-            module:{ paths:{} }
-          }
-        };
-        const res  = notModuleRegistratorRoutes.prototype.run.call(ctx, param);
-        expect(res).to.be.false;
-      });
-
-      it('paths to routes is defined', function() {
-        const ctx = {
-          findAll(){}
-        };
-        const param = {
-          nModule:{
-            module:{ paths:{routes: 'path_to_routes'} }
-          }
-        };
-        const res  = notModuleRegistratorRoutes.prototype.run.call(ctx, param);
-        expect(res).to.be.true;
-      });
-    });
-
-
-    describe('tryRouteFile', function() {
-      it('route file doesnt exists', function() {
-        const res = notModuleRegistratorRoutes.tryRouteFile({
-          srcDir: routesPath,
-          routeBasename: 'jingle'
+module.exports = ({ expect }) => {
+    describe("notModuleRegistratorRoutes", () => {
+        const routesPath = path.join(__dirname, "../testies/module/routes");
+        describe("getPath", () => {
+            it("module paths(routes)", function () {
+                const testPath = "path_to_routes";
+                const ctx = {
+                    module: {
+                        paths: {
+                            routes: testPath,
+                        },
+                    },
+                };
+                const pathTo = notModuleRegistratorRoutes.getPath(ctx);
+                expect(pathTo).to.be.equal(testPath);
+            });
         });
-        expect(res).to.be.false;
-      });
-    });
-
-    describe('tryRouteManifestFile', function() {
-      it('route file doesnt exists', function() {
-        const res = notModuleRegistratorRoutes.tryRouteManifestFile({
-          srcDir: routesPath,
-          file: 'jingle'
-        });
-        expect(res).to.be.false;
-      });
-    });
 
+        describe("run", () => {
+            it("path to routes is not defined", function () {
+                const ctx = {
+                    findAll() {},
+                };
+                const param = {
+                    nModule: {
+                        module: { paths: {} },
+                    },
+                };
+                const res = notModuleRegistratorRoutes.prototype.run.call(
+                    ctx,
+                    param
+                );
+                expect(res).to.be.false;
+            });
 
-    describe('tryWSRouteFile', function() {
-
-      it('route file doesnt exists', function() {
-        const res = notModuleRegistratorRoutes.tryWSRouteFile({
-          srcDir: routesPath,
-          routeBasename: 'jingle'
+            it("paths to routes is defined", function () {
+                const ctx = {
+                    findAll() {},
+                };
+                const param = {
+                    nModule: {
+                        module: { paths: { routes: "path_to_routes" } },
+                    },
+                };
+                const res = notModuleRegistratorRoutes.prototype.run.call(
+                    ctx,
+                    param
+                );
+                expect(res).to.be.true;
+            });
         });
-        expect(res).to.be.false;
-      });
-    });
-
 
-    describe('findOne', function() {
-      it('route manifest file doesnt exists', function() {
-        const ctx = {};
-        const param = {
-          nModule: {},
-          srcDir: routesPath,
-          file: 'mangle.manifest.js'
-        };
-        const res = notModuleRegistratorRoutes.prototype.findOne.call(ctx, param);
-        expect(res).to.be.false;
-      });
-
-      it('route and ws-route files doesnt exists', function() {
-        const ctx = {};
-        const param = {
-          nModule: {},
-          srcDir: routesPath,
-          file: 'jingle.manifest.js'
-        };
-        const res = notModuleRegistratorRoutes.prototype.findOne.call(ctx, param);
-        expect(res).to.be.false;
-      });
-
-      it('route - exists; wsRoute - !exists;', function() {
-        const ctx = {};
-        const param = {
-          nModule: {},
-          srcDir: routesPath,
-          file: 'icon.manifest.js'
-        };
-        const res = notModuleRegistratorRoutes.prototype.findOne.call(ctx, param);
-        expect(res).to.be.false;
-      });
-
-      it('route - !exists; wsRoute - exists;', function() {
-        const ctx = {
-          registerManifestAndRoutes({wsRoute}){
-            expect(wsRoute).to.be.ok;
-            expect(wsRoute.clients).to.have.keys(['main']);
-          }
-        };
-        const param = {
-          nModule: {},
-          srcDir: routesPath,
-          file: 'logo.manifest.js'
-        };
-        const res = notModuleRegistratorRoutes.prototype.findOne.call(ctx, param);
-        expect(res).to.be.true;
-      });
-
-    });
-
-
-    describe('registerManifestAndRoutes', function() {
-      it('route not exists, ws end-points exists', function() {
-        let i = 0;
-        notModuleRegistratorRoutes.prototype.registerManifestAndRoutes.call({
-          registerRoute() {
-            i++;
-          },
-          registerWSRoute() {
-            i++
-          }
-        }, {
-          nModule:{
-            setManifest(){},
-          },
-          route: false,
-          wsRoute: true
+        describe("tryRouteFile", function () {
+            it("route file doesnt exists", function () {
+                const res = notModuleRegistratorRoutes.tryRouteFile({
+                    srcDir: routesPath,
+                    routeBasename: "jingle",
+                });
+                expect(res).to.be.false;
+            });
         });
-        expect(i).to.be.equal(1);
-      });
 
-      it('route exists, ws end-points not exists', function() {
-        let i = 0;
-        notModuleRegistratorRoutes.prototype.registerManifestAndRoutes.call({
-          registerRoute() {
-            i++;
-          },
-          registerWSRoute() {
-            i++
-          }
-        }, {
-          nModule:{
-            setManifest(){},
-          },
-          route: {thisRouteName: 'asdf'},
-          wsRoute: false
+        describe("tryRouteManifestFile", function () {
+            it("route file doesnt exists", function () {
+                const res = notModuleRegistratorRoutes.tryRouteManifestFile({
+                    srcDir: routesPath,
+                    file: "jingle",
+                });
+                expect(res).to.be.false;
+            });
         });
-        expect(i).to.be.equal(1);
-      });
 
-      it('route exists, ws end-points exists', function() {
-        let i = 0;
-        notModuleRegistratorRoutes.prototype.registerManifestAndRoutes.call({
-          registerRoute() {
-            i++;
-          },
-          registerWSRoute() {
-            i++
-          }
-        }, {
-          nModule:{
-            setManifest(){},
-          },
-          route: {thisRouteName: 'asdf'},
-          wsRoute: {thisRouteName: 'asdf.ws'}
+        describe("tryWSRouteFile", function () {
+            it("route file doesnt exists", function () {
+                const res = notModuleRegistratorRoutes.tryWSRouteFile({
+                    srcDir: routesPath,
+                    routeBasename: "jingle",
+                });
+                expect(res).to.be.false;
+            });
         });
-        expect(i).to.be.equal(2);
-      });
-    });
 
+        describe("findOne", function () {
+            it("route manifest file doesnt exists", function () {
+                const ctx = {};
+                const param = {
+                    nModule: {},
+                    srcDir: routesPath,
+                    file: "mangle.manifest.js",
+                };
+                const res = notModuleRegistratorRoutes.prototype.findOne.call(
+                    ctx,
+                    param
+                );
+                expect(res).to.be.false;
+            });
 
+            it("route and ws-route files doesnt exists", function () {
+                const ctx = {};
+                const param = {
+                    nModule: {},
+                    srcDir: routesPath,
+                    file: "jingle.manifest.js",
+                };
+                const res = notModuleRegistratorRoutes.prototype.findOne.call(
+                    ctx,
+                    param
+                );
+                expect(res).to.be.false;
+            });
 
-    describe('registerRoute', function() {
-      it('notApp exists', function() {
-        const route = {
-          thisRouteName: 'filename',
-          filename: 'filename'
-        };
-        const ctx = {};
-        const param = {
-          route,
-          routeName: '',
-          fromPath: '',
-          nModule: {
-            setRoute(...params){
-              expect(params[0]).to.be.equal(route.thisRouteName);
-              expect(params[1]).to.be.deep.equal(route);
-            },
-            appIsSet(){return true;},
-            getApp(){
-              return {
-                getModel(){},
-                getModelFile(){},
-                getModelSchema(){},
-                getLogic(){},
-                getLogicFile(){},
-                getModule(){},
-              };
-            }
-          }
-        };
-        notModuleRegistratorRoutes.prototype.registerRoute.call(ctx, param);
-        expect(typeof route.getLogic).to.be.equal('function');
-        expect(typeof route.getLogicFile).to.be.equal('function');
-        expect(typeof route.getModel).to.be.equal('function');
-        expect(typeof route.getModelFile).to.be.equal('function');
-        expect(typeof route.getModelSchema).to.be.equal('function');
-        expect(typeof route.getModule).to.be.equal('function');
-        expect(typeof route.log.log).to.be.equal('function');
-        expect(typeof route.log.error).to.be.equal('function');
-        expect(typeof route.log.debug).to.be.equal('function');
+            it("route - exists; wsRoute - !exists;", function () {
+                const ctx = {};
+                const param = {
+                    nModule: {},
+                    srcDir: routesPath,
+                    file: "icon.manifest.js",
+                };
+                const res = notModuleRegistratorRoutes.prototype.findOne.call(
+                    ctx,
+                    param
+                );
+                expect(res).to.be.false;
+            });
 
-        expect(route).to.have.keys(['getThisModule', 'thisRouteName','filename', 'log', 'getModel', 'getModelFile', 'getModelSchema', 'getLogic', 'getLogicFile', 'getModule']);
-        expect(route.getThisModule()).to.be.deep.equal(param.nModule);
-      });
+            it("route - !exists; wsRoute - exists;", function () {
+                const ctx = {
+                    getFileBasename() {
+                        return "logo";
+                    },
+                    registerManifestAndRoutes({ wsRoute }) {
+                        expect(wsRoute).to.be.ok;
+                        console.log(Object.keys(wsRoute.clients));
+                        expect(wsRoute.clients).to.have.keys(["main"]);
+                    },
+                };
+                const param = {
+                    nModule: {},
+                    srcDir: routesPath,
+                    file: "logo.manifest.js",
+                };
+                const res = notModuleRegistratorRoutes.prototype.findOne.call(
+                    ctx,
+                    param
+                );
+                expect(res).to.be.true;
+            });
+        });
 
-      it('notApp doesnt exists', function() {
-        const route = {
-          thisRouteName: 'filename',
-          filename: 'filename'
-        };
-        const ctx = {};
-        const param = {
-          route,
-          routeName: '',
-          fromPath: '',
-          nModule: {
-            setRoute(...params){
-              expect(params[0]).to.be.equal(route.thisRouteName);
-              expect(params[1]).to.be.deep.equal(route);
-            },
-            appIsSet(){return false;},
-            getApp(){
-              return {
-                getModel(){},
-                getModelFile(){},
-                getModelSchema(){},
-                getLogic(){},
-                getLogicFile(){},
-                getModule(){},
-              };
-            }
-          }
-        };
-        notModuleRegistratorRoutes.prototype.registerRoute.call(ctx, param);
+        describe("registerManifestAndRoutes", function () {
+            it("route not exists, ws end-points exists", function () {
+                let i = 0;
+                notModuleRegistratorRoutes.prototype.registerManifestAndRoutes.call(
+                    {
+                        registerRoute() {
+                            i++;
+                        },
+                        registerWSRoute() {
+                            i++;
+                        },
+                    },
+                    {
+                        nModule: {
+                            setManifest() {},
+                        },
+                        route: false,
+                        wsRoute: true,
+                    }
+                );
+                expect(i).to.be.equal(1);
+            });
 
-        expect(typeof route.log.log).to.be.equal('function');
-        expect(typeof route.log.error).to.be.equal('function');
-        expect(typeof route.log.debug).to.be.equal('function');
+            it("route exists, ws end-points not exists", function () {
+                let i = 0;
+                notModuleRegistratorRoutes.prototype.registerManifestAndRoutes.call(
+                    {
+                        registerRoute() {
+                            i++;
+                        },
+                        registerWSRoute() {
+                            i++;
+                        },
+                    },
+                    {
+                        nModule: {
+                            setManifest() {},
+                        },
+                        route: { thisRouteName: "asdf" },
+                        wsRoute: false,
+                    }
+                );
+                expect(i).to.be.equal(1);
+            });
 
-        expect(route).to.have.keys(['getThisModule', 'thisRouteName', 'filename', 'log']);
-        expect(route.getThisModule()).to.be.deep.equal(param.nModule);
-      });
-    });
+            it("route exists, ws end-points exists", function () {
+                let i = 0;
+                notModuleRegistratorRoutes.prototype.registerManifestAndRoutes.call(
+                    {
+                        registerRoute() {
+                            i++;
+                        },
+                        registerWSRoute() {
+                            i++;
+                        },
+                    },
+                    {
+                        nModule: {
+                            setManifest() {},
+                        },
+                        route: { thisRouteName: "asdf" },
+                        wsRoute: { thisRouteName: "asdf.ws" },
+                    }
+                );
+                expect(i).to.be.equal(2);
+            });
+        });
 
+        describe("registerRoute", function () {
+            it("notApp exists", function () {
+                const route = {
+                    thisRouteName: "filename",
+                    filename: "filename",
+                };
+                const ctx = {};
+                const param = {
+                    route,
+                    routeName: "",
+                    fromPath: "",
+                    nModule: {
+                        setRoute(...params) {
+                            expect(params[0]).to.be.equal(route.thisRouteName);
+                            expect(params[1]).to.be.deep.equal(route);
+                        },
+                        appIsSet() {
+                            return true;
+                        },
+                        getApp() {
+                            return {
+                                getModel() {},
+                                getModelFile() {},
+                                getModelSchema() {},
+                                getLogic() {},
+                                getLogicFile() {},
+                                getModule() {},
+                            };
+                        },
+                    },
+                };
+                notModuleRegistratorRoutes.prototype.registerRoute.call(
+                    ctx,
+                    param
+                );
+                expect(typeof route.getLogic).to.be.equal("function");
+                expect(typeof route.getLogicFile).to.be.equal("function");
+                expect(typeof route.getModel).to.be.equal("function");
+                expect(typeof route.getModelFile).to.be.equal("function");
+                expect(typeof route.getModelSchema).to.be.equal("function");
+                expect(typeof route.getModule).to.be.equal("function");
+                expect(typeof route.log.log).to.be.equal("function");
+                expect(typeof route.log.error).to.be.equal("function");
+                expect(typeof route.log.debug).to.be.equal("function");
 
+                expect(route).to.have.keys([
+                    "getThisModule",
+                    "thisRouteName",
+                    "filename",
+                    "log",
+                    "getModel",
+                    "getModelFile",
+                    "getModelSchema",
+                    "getLogic",
+                    "getLogicFile",
+                    "getModule",
+                ]);
+                expect(route.getThisModule()).to.be.deep.equal(param.nModule);
+            });
 
-  });
+            it("notApp doesnt exists", function () {
+                const route = {
+                    thisRouteName: "filename",
+                    filename: "filename",
+                };
+                const ctx = {};
+                const param = {
+                    route,
+                    routeName: "",
+                    fromPath: "",
+                    nModule: {
+                        setRoute(...params) {
+                            expect(params[0]).to.be.equal(route.thisRouteName);
+                            expect(params[1]).to.be.deep.equal(route);
+                        },
+                        appIsSet() {
+                            return false;
+                        },
+                        getApp() {
+                            return {
+                                getModel() {},
+                                getModelFile() {},
+                                getModelSchema() {},
+                                getLogic() {},
+                                getLogicFile() {},
+                                getModule() {},
+                            };
+                        },
+                    },
+                };
+                notModuleRegistratorRoutes.prototype.registerRoute.call(
+                    ctx,
+                    param
+                );
 
+                expect(typeof route.log.log).to.be.equal("function");
+                expect(typeof route.log.error).to.be.equal("function");
+                expect(typeof route.log.debug).to.be.equal("function");
 
+                expect(route).to.have.keys([
+                    "getThisModule",
+                    "thisRouteName",
+                    "filename",
+                    "log",
+                ]);
+                expect(route.getThisModule()).to.be.deep.equal(param.nModule);
+            });
+        });
+    });
 };

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

@@ -4,44 +4,42 @@ const { MODULE_NAME } = require("../const");
 const Form = require("not-node").Form;
 //form
 const FIELDS = [
-<% if (fields && Array.isArray(fields)) { %>
-    <% for(let field of fields){ %>
-        "<%- field %>",
-            <% } %>
-                <% } %>
-                    ];
+["activeUser", "not-node//requiredObject"],
+["data", `${MODULE_NAME}//_<%- ModelName %>_data`],
+    ["ip", "not-node//ip"],
+    ];
 
-                    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 });
-                            }
+        /**
+        *
+        **/
+        module.exports = 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+': "extractFromBody" ,' -%>
-                                        <% } %>
-                                            <% } %>
-                                                owner: "activeUserId",
-                                                ownerModel: "activeUserModelName",
-                                                };
-                                                const data = this.extractByInstructions(req, instructions);
-                                                return {
-                                                activeUser: req.user,
-                                                ip,
-                                                data,
-                                                };
-                                                }
-                                                };
+            /**
+            * 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,
+                                };
+                                }
+                                };

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

@@ -19,7 +19,7 @@ const FIELDS = [
             const instructions = {
             <% if (fields && Array.isArray(fields)) { %>
                 <% for(let field of fields){ %>
-                    <%- field+': "extractFromBody" ,' -%>
+                    <%- field+': "fromBody" ,' -%>
                         <% } %>
                             <% } %>
                                 owner: "fromBody",

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

@@ -2,31 +2,31 @@ const notNode = require("not-node");
 const { notValidationError } = require("not-error");
 
 module.exports = async (
-    /**
-    *   Values to validate in form
-    */
-    {owner, ownerModel, vals, to , validate }, 
-    /**
-    * special container to pass around global validation libs, CONSTs and inject other entities
-    */
-    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
-            }
-        );
+/**
+* Values to validate in form
+*/
+{owner, ownerModel, vals, to , validate },
+/**
+* special container to pass around global validation libs, CONSTs and inject other entities
+*/
+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
     }
-};
+    );
+    }
+    };

package/bin/not-deploy.js

@@ -1,52 +0,0 @@
-/**
-
-#!/bin/bash
-cwd
-echo 'deploying to production'
-cd reporter 
-npm run production 
-cd ../
-echo 'syncing data'
-rsync -av --progress --exclude-from='./deploy/.exclude' reporter cypher@appmon.ru:/var/server/appmon.ru/ 
-rsync -av --progress deploy/production.json cypher@appmon.ru:/var/server/appmon.ru/deploy/production.json 
-ssh cypher@appmon.ru "cd /var/server/appmon.ru/reporter && npm i"
-ssh cypher@appmon.ru "cd /var/server/appmon.ru && pm2 startOrRestart deploy/production.json"
-exit 0;
-
-read config
-cycle through remote locations
-deploy as selected method in config say
-
-{
-    deploy:{
-        stage:{},
-        production:{
-            src:{
-                type: "fs",                         //fs, git
-                location: "/var/work/project",      //path to dir or url of repo
-                include: [],                        //optional, files to not copy
-                exclude: [],                        //optional, files to not copy
-                //will be executed localy
-                before-setup:     "",               //optional, shell cmd
-                after-setup:      "",               //optional, shell cmd
-                before:     "",                     //optional, shell cmd
-                after:      "",                     //optional, shell cmd
-                secret:     "./production.env"      //optional
-            },
-            dest:{
-                username:  "deploy-master-3000",  //
-                server: ["username@server", "10.0.1.12"],        //
-                path: "/path/on/server",            //
-                //will be executed on remote side
-                before-setup:     "",               //optional, shell cmd
-                after-setup:      "",               //optional, shell cmd
-                before:     "",                     //optional, shell cmd
-                after:      "",                     //optional, shell cmd
-                secret: "/path/on/server/where/secret_should_be_copied" //optional
-            }
-        }
-    }
-}
-
-
-**/

package/bin/not-mongo.sh

@@ -1 +0,0 @@
-#!/bin/bash

package/static.js

@@ -1,31 +0,0 @@
-const generate = ({ NAME }) => {
-    return class {
-        static run(prefix) {
-            return prefix + NAME;
-        }
-
-        static faster(prefix) {
-            return this.run(prefix) + " is faster";
-        }
-    };
-};
-
-const proto1 = generate({ NAME: "sonic" });
-const proto2 = generate({ NAME: "lorde" });
-const proto3 = generate({ NAME: "vanish" });
-
-class res1 extends proto1 {
-    static faster(prefix) {
-        return this.run(prefix) + " is even faster";
-    }
-}
-
-class res2 extends proto2 {}
-
-class res3 extends proto3 {}
-
-console.log(res1.run("res 1 - "));
-console.log(res1.faster("res 1 - "));
-console.log(proto3.run("proto 3 - "));
-console.log(res3.run("res 3 - "));
-console.log(res2.faster("res 2 - "));

package/static2.js

@@ -1,24 +0,0 @@
-class Parent {
-    static getOptions() {
-        return this.#options;
-    }
-
-    static setOptions(opts) {
-        this.#options = opts;
-    }
-}
-
-class Child extends Parent {
-    static #options = {};
-    constructor() {
-        super();
-    }
-
-    run() {
-        Child.getOptions();
-    }
-}
-
-Parent.setOptions({ 1: "1" });
-
-console.log(new Child().run());