not-node 6.0.7 → 6.1.0

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

@@ -0,0 +1,49 @@
+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"],
+];
+
+const FORM_NAME = `${MODULE_NAME}:CreateForm`;
+const USER_MODEL_NAME = "User";
+/**
+ *
+ **/
+module.exports = class 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 = {
+            title: "fromBody",
+            keys: "fromBody",
+            owner: "fromBody", //req.body.owner || req.user._id.toString(),
+            ownerModel: "fromBody", //req.body.ownerModel || USER_MODEL_NAME,
+        };
+        const data = this.extractByInstructions(req, instructions);
+
+        if (!req.user.isRoot() && !req.user.isAdmin()) {
+            data.owner = req.user._id.toString();
+            data.ownerModel = USER_MODEL_NAME;
+        }
+
+        return {
+            data,
+            activeUser: req.user,
+            ip,
+        };
+    }
+};

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

@@ -0,0 +1,3 @@
+{
+    "code_name": "some line with {:may.be.some.params}, {:or.two}"
+}

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

@@ -0,0 +1,73 @@
+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,
+});
+
+const populateBuilders = {};
+
+const <%- ModelName %>GenericLogic = notNode.Generic.GenericLogic({
+    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;
+        }
+    <% } %>
+    <% } %>
+}
+
+module.exports[MODEL_NAME] = <%- ModelName %>Logic;

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

@@ -0,0 +1,68 @@
+const MODEL_NAME = "<%- ModelName %>";
+
+module.exports.thisModelName = MODEL_NAME;
+module.exports.keepNotExtended = false;
+
+module.exports.enrich = {
+    versioning: <%= versioning %>,
+    increment: <%= increment?true:false %>,
+    <% if (increment && increment?.options){ %>
+    incrementOptions: {
+        <% if (increment.options?.filter){ %>        
+        filter: [<%- increment.options.filter.map((entry) => `"${entry}"`).join(',') %>],
+        <% } %>
+    },
+    <% } %>
+    validators: <%= validators %>,
+};
+
+const FIELDS = [
+    <% if (fields && Array.isArray(fields)) { %>
+    <% for(let field of fields){ %>
+    "<%- field %>",
+    <% } %>
+    <% } %>
+    ["owner", "not-node//owner"],
+    ["ownerModel", "not-node//ownerModel"],
+    ["createdAt", "not-node//createdAt"],
+    ["updatedAt", "not-node//updatedAt"],
+];
+
+module.exports.FIELDS = FIELDS;
+
+module.exports.thisStatics = {
+    
+};
+
+module.exports.thisMethods = {
+    
+};
+
+
+module.exports.thisVirtuals = {
+    
+};
+
+module.exports.thisPre = {
+    updateOne: async () => {
+        //	console.debug('model pre updateOne');
+    },
+    insert: async () => {
+        //console.log('model pre insert');
+    },
+    save: async () => {
+        //console.log('model pre save');
+    },
+    update: async () => {
+        //console.log('model pre update' );
+    },
+};
+
+module.exports.thisPost = {
+    save: async () => {
+        //console.log('model post save');
+    },
+    update: async () => {
+        //console.log('model post update');
+    },
+};

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

@@ -0,0 +1,50 @@
+const { MODULE_NAME } = require("../const");
+const MODEL_NAME = "<%- ModelName %>";
+const notNode = require("not-node");
+
+const {
+    //	say,
+    //	config,
+    //	Log,
+    before,
+    after,
+    getLogic,
+    //	getModel,
+    //	getModelSchema,
+} = notNode.Bootstrap.notBootstrapRoute({
+    target: module,
+    MODEL_NAME,
+    MODULE_NAME,
+    defaultAccessRule: true,
+});
+
+const <%- ModelName %>GenericRoute = notNode.Generic.GenericRoute({
+    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 (layers.includes('forms') && !layers.includes('logics')){ %>
+        return {...prepared};
+        <% } %>
+
+        <% if (!layers.includes('forms') && layers.includes('logics')){ %>
+        return await getLogic().<%- actionName %>();
+        <% } %>
+    }
+    <% } %>   
+    <% } %>   
+}
+
+module.exports = <%- ModelName %>Route;

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

@@ -0,0 +1,211 @@
+const FIELDS = [
+    ["_id", "not-node//_id"],
+    ["<%- modelName %>ID", "not-node//ID"],
+    <% if (fields && Array.isArray(fields)) { %>
+    <% for(let field of fields){ %>
+    "<%- field %>",
+    <% } %>
+    <% } %>
+    ["owner", "not-node//owner"],
+    ["ownerModel", "not-node//ownerModel"],
+    ["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",
+            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",
+            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",
+            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",
+            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: {
+            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",
+            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",
+            data: ["record", "sorter"],
+            fields: [
+            <%- fields.map((entry) => `"${entry}"`).join(',')  %>,
+                "createdAt",
+                "updatedAt",
+            ],
+            postFix: actionNamePath,
+            rules: [
+                {
+                    root: true,
+                },
+                {
+                    auth: true,
+                    role: ["manager"],
+                },
+                {
+                    auth: true,
+                },
+            ],
+        },
+        <% } %>
+    },
+};

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

@@ -0,0 +1,29 @@
+const notNode = require("not-node");
+const { MODULE_NAME } = require("../const");
+const MODEL_NAME = "<%- ModelName %>";
+
+const getLogic = () =>
+    notNode.Application.getLogic(`${MODULE_NAME}//${MODEL_NAME}`);
+
+
+async function someAction({ data, client }) {
+    return await getLogic().getData({
+        data,
+        activeUser: client.identity,
+        ip: client.getIP(),
+        root: false,
+    });
+}
+
+module.exports = {
+    servers: {
+        main: {
+            request: {
+                someAction
+            },
+            event:{
+
+            }
+        },
+    },
+};

package/tmpl/files/module.server/validationEnv.ejs

@@ -0,0 +1,5 @@
+const validator = require('validator');
+
+module.exports = ()=>{
+	return {validator};
+};

package/tmpl/files/notComponent.ejs

@@ -0,0 +1,57 @@
+import UI<%- ComponentName %> from "./<%- componentName %>.svelte";
+
+class not<%- ComponentName %> extends notBase{
+
+    static UIConstructor = UI<%- ComponentName %>;
+ 
+    constructor({
+      target = null,
+      name = "Default",
+      options = {},
+      working = {},
+      data = {},
+    }){
+      super({
+        working: {
+            name: `${name}<%- ComponentName %>`,
+            ...working,
+        },
+        options,
+        data,
+      });
+      if (target) {
+        this.setOptions("target", target);
+      }
+      this.render();
+    }
+  
+    render(){
+      this.remove();
+      if(this.UIConstructor){
+        this.ui = new this.UIConstructor({
+          target: this.getOptions('target'),
+          props:{
+            /* props */
+          }
+        });
+      }
+    }    
+  
+    update(){
+      if(this.ui){
+        this.ui.$set({ /* update props */ });
+      }
+    }
+  
+    remove(){
+      if (this.ui) {
+        this.ui.$destroy();
+        this.ui = null;
+      }
+      return this;
+    }
+  
+  }
+  
+  export default not<%- ComponentName %>;
+  

package/tmpl/files/notService.ejs

@@ -0,0 +1,39 @@
+  const INTERVAL = 360;
+  const INIT_UPDATE_DELAY = 5;
+  
+  class ns<%- ServiceName %> {
+    #INTERVAL = INTERVAL;
+    #INIT_UPDATE_DELAY = INIT_UPDATE_DELAY;
+  
+    constructor(app) {
+      this.app = app;      
+      <% if(modelName){ %>
+      this.interface = this.app.getInterface("<%- modelName %>"");
+      if(this.interface){
+        this.init();
+      }else{
+        app.error('no network interface');
+      }
+      <% }else{ %>
+      this.init();
+      <% } %>
+    };
+  
+    init() {
+      setTimeout(this.update.bind(this), this.#INIT_UPDATE_DELAY * 100);
+      this.int = setInterval(this.update.bind(this), this.#INTERVAL * 1000);
+      window.addEventListener('unload', () => {
+        clearInterval(this.int);
+        delete this.app;
+        <% if(modelName){ %>
+        delete this.interface;
+        <% } %>
+      });
+    }
+  
+    update() {
+      //serve
+    }}
+
+
+export default ns<%- ServiceName %>;