zet-lib 1.4.0 → 1.4.1

package/lib/zCache.js

@@ -1,301 +1,305 @@
-const myCache = require('./cache')
-const connection = require('./connection')
-const Util = require('./Util')
-const path = require('path')
-const fs = require('fs-extra')
-const directory = './'
-const zRoute = require('./zRoute')
+const myCache = require("./cache");
+const connection = require("./connection");
+const Util = require("./Util");
+const path = require("path");
+const fs = require("fs-extra");
+const directory = "./";
+const zRoute = require("./zRoute");
 
-const zCache = {}
+const zCache = {};
 
 //constants
 zCache.KEYS = {
-  ROUTES: 'ROUTES',
-  MYMODELS: 'MYMODELS',
-  ROLES: 'ROLES',
-  CONFIG: 'CONFIG',
-  MENU: 'MENU',
-  MENU_SYSTEMS: 'MENU_SYSTEMS',
-  ZFUNCTIONS: 'ZFUNCTIONS',
-  VERSIONS: 'VERSIONS',
-  MODELS_RELATIONS: 'MODELS_RELATIONS',
-  APPROVAL_LEVELS: 'APPROVAL_LEVELS',
-}
+  ROUTES: "ROUTES",
+  MYMODELS: "MYMODELS",
+  ROLES: "ROLES",
+  CONFIG: "CONFIG",
+  MENU: "MENU",
+  MENU_SYSTEMS: "MENU_SYSTEMS",
+  ZFUNCTIONS: "ZFUNCTIONS",
+  VERSIONS: "VERSIONS",
+  MODELS_RELATIONS: "MODELS_RELATIONS",
+  APPROVAL_LEVELS: "APPROVAL_LEVELS",
+};
 
-zCache.STATICS = zCache.KEYS
-zCache.myCache = myCache
+zCache.STATICS = zCache.KEYS;
+zCache.myCache = myCache;
 
-zCache.get = (name = '') => {
+zCache.get = (name = "") => {
   if (!myCache.has(name)) {
-    zCache[name]()
+    zCache[name]();
   } else {
-    return myCache.get(name)
+    return myCache.get(name);
   }
-}
+};
 
 zCache.set = (X, Y) => {
-  myCache.set(X, Y)
-}
+  myCache.set(X, Y);
+};
 
 zCache.cache = async (req, res, next) => {
-  await cache()
-  next()
-}
+  await cache();
+  next();
+};
 
 const cache = async () => {
-  zCache.VERSIONS()
-  let i = 0
-  if (myCache.has('ROLES')) {
+  zCache.VERSIONS();
+  let i = 0;
+  if (myCache.has("ROLES")) {
     //console.log("cache ROLES has exist " + i)
-    i = i + 1
+    i = i + 1;
   } else {
     //console.log("cache ROLES not exist " + i)
-    await zCache.ROLES()
+    await zCache.ROLES();
   }
-  if (myCache.has('ROUTES')) {
-    i = i + 1
+  if (myCache.has("ROUTES")) {
+    i = i + 1;
   } else {
-    await zCache.ROUTES()
+    await zCache.ROUTES();
   }
-  if (myCache.has('MYMODELS')) {
-    i = i + 1
+  if (myCache.has("MYMODELS")) {
+    i = i + 1;
   } else {
-    await zCache.MYMODELS()
+    await zCache.MYMODELS();
   }
-  if (myCache.has('MENU')) {
-    i = i + 1
+  if (myCache.has("MENU")) {
+    i = i + 1;
   } else {
     //console.log("cache MENU not exist " + i);
     //zup.menu();
-    await zCache.MENU()
+    await zCache.MENU();
   }
-  if (myCache.has('MENU_SYSTEMS')) {
+  if (myCache.has("MENU_SYSTEMS")) {
     //i = i + 1;
   } else {
-    await zCache.MENU_SYSTEMS()
+    await zCache.MENU_SYSTEMS();
   }
   //console.log(i)
-  if (myCache.has('ZFUNCTIONS')) {
+  if (myCache.has("ZFUNCTIONS")) {
     //i = i + 1;
   } else {
-    await zCache.ZFUNCTIONS()
+    await zCache.ZFUNCTIONS();
   }
-  if (myCache.has('APPROVAL_LEVELS')) {
-    i = i + 1
+  if (myCache.has("APPROVAL_LEVELS")) {
+    i = i + 1;
   } else {
-    await zCache.APPROVAL_LEVELS()
+    await zCache.APPROVAL_LEVELS();
   }
   //await zCache.CURRENCIES();
   //console.log(i)
   if (i < 5) {
-    await cache()
+    await cache();
   } else {
-    return i
+    return i;
   }
   //cache relations on startup
-  await zCache.MODELS_RELATIONS()
-}
+  await zCache.MODELS_RELATIONS();
+};
 
 zCache.renew = async () => {
-  zCache.VERSIONS()
-  await zCache.ROLES()
-  await zCache.MENU()
-  await zCache.CONFIG()
-  await zCache.ROUTES()
-  await zCache.MYMODELS()
-  await zCache.MENU_SYSTEMS()
-  await zCache.MODELS_RELATIONS()
-  await zCache.APPROVAL_LEVELS()
-}
+  zCache.VERSIONS();
+  await zCache.ROLES();
+  await zCache.MENU();
+  await zCache.CONFIG();
+  await zCache.ROUTES();
+  await zCache.MYMODELS();
+  await zCache.MENU_SYSTEMS();
+  await zCache.MODELS_RELATIONS();
+  await zCache.APPROVAL_LEVELS();
+};
 
 zCache.ROUTES = () => {
-  if (myCache.has('ROUTES')) {
-    return myCache.get('ROUTES')
+  if (myCache.has("ROUTES")) {
+    return myCache.get("ROUTES");
   } else {
-    const routes = zRoute.ROUTES()
-    myCache.set('ROUTES', routes)
-    return routes
+    const routes = zRoute.ROUTES();
+    myCache.set("ROUTES", routes);
+    return routes;
   }
-}
+};
 
 zCache.MYMODELS = () => {
-  if (myCache.has('MYMODELS')) {
-    return myCache.get('MYMODELS')
+  if (myCache.has("MYMODELS")) {
+    return myCache.get("MYMODELS");
   } else {
-    const models = zRoute.MYMODELS()
-    myCache.set('MYMODELS', models)
-    return models
+    const models = zRoute.MYMODELS();
+    myCache.set("MYMODELS", models);
+    return models;
   }
-}
+};
 
 zCache.ROLES = async () => {
-  let r = 0
-  let results = await connection.results({ table: 'zrole' })
-  let obj = Util.arrayToObject(results, 'id')
-  await myCache.set('ROLES', obj)
+  let r = 0;
+  let results = await connection.results({ table: "zrole" });
+  let obj = Util.arrayToObject(results, "id");
+  await myCache.set("ROLES", obj);
   //add to version after set
-  zCache.updateVersions('ROLES')
-  r = 1
-  return r
-}
+  zCache.updateVersions("ROLES");
+  r = 1;
+  return r;
+};
 
 zCache.ZFUNCTIONS = async () => {
   let query = await connection.results({
-    table: 'zfunction',
+    table: "zfunction",
     where: {
       active: 1,
     },
-  })
+  });
   if (query.length) {
-    let results = await connection.results({ table: 'zfunction' })
-    let obj = Util.arrayToObject(results, 'title')
-    await myCache.set('ZFUNCTIONS', obj)
+    let results = await connection.results({ table: "zfunction" });
+    let obj = Util.arrayToObject(results, "title");
+    await myCache.set("ZFUNCTIONS", obj);
     //add to version after set
-    zCache.updateVersions('ZFUNCTIONS')
+    zCache.updateVersions("ZFUNCTIONS");
   }
-}
+};
 
 zCache.VERSIONS = () => {
-  if (myCache.has('VERSIONS')) {
+  if (myCache.has("VERSIONS")) {
     //console.log("VERSIONS")
-    return myCache.get('VERSIONS')
+    return myCache.get("VERSIONS");
   } else {
-    let obj = {}
+    let obj = {};
     for (let key in zCache.KEYS) {
-      obj[key] = 0
+      obj[key] = 0;
     }
-    myCache.set('VERSIONS', obj)
+    myCache.set("VERSIONS", obj);
     //console.log(JSON.stringify(myCache.get("VERSIONS")))
-    return obj
+    return obj;
   }
-}
+};
 
 zCache.MENU = async () => {
   let results = async () => {
     return await connection.results({
-      table: 'zmenu',
+      table: "zmenu",
       where: {
         active: 1,
       },
-    })
-  }
-  const r = await results()
+    });
+  };
+  const r = await results();
   const builder = async () => {
-    let obj = {}
-    let arr = await results()
+    let obj = {};
+    let arr = await results();
     arr.map((item) => {
-      obj[item.company_id] = item.json || []
-    })
-    myCache.set('MENU', obj)
+      obj[item.company_id] = item.json || [];
+    });
+    myCache.set("MENU", obj);
     //add to version after set
-    zCache.updateVersions('MENU')
-  }
+    zCache.updateVersions("MENU");
+  };
   if (r.length) {
-    await builder()
+    await builder();
   }
-}
+};
 
 zCache.MENU_SYSTEMS = () => {
-  let obj = {}
+  let obj = {};
   obj.users = [
     {
-      text: 'LANGUAGE.users',
-      href: 'zuser',
+      text: "LANGUAGE.users",
+      href: "zuser",
     },
     {
-      text: 'LANGUAGE.user_access',
-      href: 'zuser_company',
+      text: "LANGUAGE.access_role",
+      href: "zrole",
     },
     {
-      text: 'LANGUAGE.company',
-      href: 'zcompany',
+      text: "LANGUAGE.logs_uploads",
+      href: "zlogs_upload",
     },
     {
-      text: 'LANGUAGE.access_role',
-      href: 'zrole',
+      text: "LANGUAGE.user_access",
+      href: "zuser_company",
     },
     {
-      text: 'LANGUAGE.logs_uploads',
-      href: 'zlogs_upload',
+      text: "LANGUAGE.company",
+      href: "zcompany",
     },
-  ]
+  ];
   obj.systems = [
     {
-      text: 'Generator',
-      href: 'zgenerator',
+      text: "Generator",
+      href: "zgenerator",
+    },
+    {
+      text: "Menu Generator",
+      href: "zmenu",
     },
     {
-      text: 'Menu Generator',
-      href: 'zmenu',
+      text: "View Generator",
+      href: "zviewgenerator",
     },
     {
-      text: 'Grid Default',
-      href: 'zgrid_default',
+      text: "Grid Default",
+      href: "zgrid_default",
     },
     {
-      text: 'Routers',
-      href: 'zpage',
+      text: "Routers",
+      href: "zpage",
     },
     {
-      text: 'Functions',
-      href: 'zfunction',
+      text: "Functions",
+      href: "zfunction",
     },
     {
-      text: 'Layouts',
-      href: 'zlayout',
+      text: "Layouts",
+      href: "zlayout",
     },
     {
-      text: 'Custom Report',
-      href: 'zreports',
+      text: "Custom Report",
+      href: "zreports",
     },
     {
-      text: 'Log Errors',
-      href: 'zerror',
+      text: "Log Errors",
+      href: "zerror",
     },
-  ]
-  myCache.set('MENU_SYSTEMS', obj)
-}
+  ];
+  myCache.set("MENU_SYSTEMS", obj);
+};
 
 zCache.updateVersions = (name) => {
-  let obj = myCache.get('VERSIONS') || {}
+  let obj = myCache.get("VERSIONS") || {};
   if (!obj.ROLES) {
-    zCache.VERSIONS()
-    obj = myCache.get('VERSIONS')
+    zCache.VERSIONS();
+    obj = myCache.get("VERSIONS");
   }
-  let value = obj[name] || 0
-  value++
-  obj[name] = value
-  myCache.set('VERSIONS', obj)
-}
+  let value = obj[name] || 0;
+  value++;
+  obj[name] = value;
+  myCache.set("VERSIONS", obj);
+};
 
 zCache.MODELS_RELATIONS = async () => {
   if (process.env.APP_IS_CACHE == 1) {
-    console.log('cache models')
-    if (myCache.has('MODELS_RELATIONS')) {
-      return myCache.get('MODELS_RELATIONS')
+    console.log("cache models");
+    if (myCache.has("MODELS_RELATIONS")) {
+      return myCache.get("MODELS_RELATIONS");
     } else {
-      const obj = await zRoute.modelsCache()
-      myCache.set('MODELS_RELATIONS', obj)
-      return obj
+      const obj = await zRoute.modelsCache();
+      myCache.set("MODELS_RELATIONS", obj);
+      return obj;
     }
   } else {
-    console.log('not cache models')
-    return {}
+    console.log("not cache models");
+    return {};
   }
-}
+};
 
 zCache.APPROVAL_LEVELS = async () => {
-  if (myCache.has('APPROVAL_LEVELS')) {
-    return myCache.get('APPROVAL_LEVELS')
+  if (myCache.has("APPROVAL_LEVELS")) {
+    return myCache.get("APPROVAL_LEVELS");
   } else {
     let results = await connection.results({
-      select: 'id,name,color',
-      table: 'zapproval_type',
-    })
-    let obj = Util.arrayToObject(results, 'id')
-    myCache.set('APPROVAL_LEVELS', obj)
-    return obj
+      select: "id,name,color",
+      table: "zapproval_type",
+    });
+    let obj = Util.arrayToObject(results, "id");
+    myCache.set("APPROVAL_LEVELS", obj);
+    return obj;
   }
-}
+};
 
-module.exports = zCache
+module.exports = zCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zet-lib",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "zet is a library that part of zet generator.",
   "engines": {
     "node": ">=18"