not-node 6.3.75 → 6.3.77

package/package.json

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

package/src/init/index.js

@@ -106,8 +106,8 @@ class Init {
     }
 
     static printOutManifest = () => {
-        log.debug("Manifest:");
-        log.debug(JSON.stringify(Init.notApp.getManifest(), null, 4));
+        log?.debug("Manifest:");
+        log?.debug(JSON.stringify(Init.notApp.getManifest(), null, 4));
     };
 
     /**
@@ -122,7 +122,7 @@ class Init {
 
     static async run({ config, options, manifest, additional }) {
         try {
-            log.info("Kick start app..." + os.platform() + " " + os.arch());
+            log?.info("Kick start app..." + os.platform() + " " + os.arch());
             ADDS.init(additional);
             const initSequence = new InitSequence(STANDART_INIT_SEQUENCE);
             await ADDS.run("pre", {
@@ -159,8 +159,8 @@ class Init {
     }
 
     static throwError(errMsg = "Fatal error", errCode = 1) {
-        log.error(errMsg);
-        log.log(`Exit process...with code ${errCode}`);
+        log?.error(errMsg);
+        log?.log(`Exit process...with code ${errCode}`);
         throw new Error(errMsg);
     }
 }

package/src/init/lib/app.js

@@ -38,10 +38,10 @@ module.exports = class InitApp {
 
     static async importModules({ config, options, master, emit }) {
         await emit("app.importModules.pre", { config, options, master });
-        master.getApp().importModulesFrom(config.get("modulesPath"));
+        master.getApp().importModulesFrom(master.getEnv("modulesPath"));
         if (Array.isArray(config.get("importModulesFromNPM"))) {
             config.get("importModulesFromNPM").forEach((modName) => {
-                const modPath = path.join(config.get("npmPath"), modName);
+                const modPath = path.join(master.getEnv("npmPath"), modName);
                 master.getApp().importModuleFrom(modPath, modName);
             });
         }
@@ -63,13 +63,13 @@ module.exports = class InitApp {
 
     async run({ config, options, master, emit }) {
         try {
-            log.info("Init not-app...");
+            log?.info("Init not-app...");
             await emit("app.pre", { config, options, master });
             await InitApp.createApp({ config, options, master, emit });
             await InitApp.setAppEnvs({ config, options, master, emit });
             await InitApp.initCore({ config, options, master, emit });
             await InitApp.importModules({ config, options, master, emit });
-            await InitApp.createReporter({ config, options, master, emit });
+            await InitApp.createReporter({ config, master });
             await emit("app.post", { config, options, master });
         } catch (e) {
             master.throwError(e.message, 1);

package/src/init/lib/env.js

@@ -1,6 +1,6 @@
 const log = require("not-log")(module, "not-node//init//env");
 const { tryDirAsync } = require("../../common");
-const notEnv = require("../../env");
+
 const {
     DEFAULT_PATH_WS,
     DEFAULT_PATH_MODULES,
@@ -60,25 +60,37 @@ module.exports = class InitENV {
     static async checkPaths(master, config) {
         const paths = config.get("path");
         if (paths) {
+            log?.log("Paths existence check");
             for (let pathName of Object.keys(paths)) {
-                if (await tryDirAsync(paths[pathName])) {
-                    log?.error(
-                        `config path (${pathName}) not exists: ${paths[pathName]}`
-                    );
+                const absolutePath = master.getEnv(`${pathName}Path`);
+                if (absolutePath) {
+                    if (!(await tryDirAsync(absolutePath))) {
+                        log?.error(
+                            `config path (${pathName}) not exists: ${paths[pathName]} - ${absolutePath}`
+                        );
+                    } else {
+                        log?.log(
+                            `config path (${pathName}) exists: ${paths[pathName]} - ${absolutePath}`
+                        );
+                    }
                 }
             }
         }
     }
 
-    static addToEnv(key, val) {
-        notEnv.set(key, val);
+    static addToEnv(master, key, val) {
+        master.setEnv(key, val);
         return val;
     }
 
     static setObsoleteAndNew({ config, master, from, to, def }) {
         config.set(
             to,
-            InitENV.addToEnv(to, master.getAbsolutePath(config.get(from, def))),
+            InitENV.addToEnv(
+                master,
+                to,
+                master.getAbsolutePath(config.get(from, def))
+            ),
             `obsolete: use notEnv.get('${to}') instead`
         );
     }
@@ -105,19 +117,20 @@ module.exports = class InitENV {
 
         config.set(
             "appPath",
-            InitENV.addToEnv("appPath", options.pathToApp),
+            InitENV.addToEnv(master, "appPath", options.pathToApp),
             "obsolete: use notEnv.get('appPath')"
         );
 
         config.set(
             "npmPath",
-            InitENV.addToEnv("npmPath", options.pathToNPM),
+            InitENV.addToEnv(master, "npmPath", options.pathToNPM),
             "obsolete: use notEnv.get('npmPath')"
         );
 
         config.set(
             "fullServerName",
             InitENV.addToEnv(
+                master,
                 "fullServerName",
                 InitENV.getFullServerName(config)
             ),

package/test/init/app.js

@@ -205,6 +205,9 @@ module.exports = ({ expect }) => {
                     getManifest() {
                         return fakeManifest;
                     },
+                    getEnv(name) {
+                        return `${name}_fake`;
+                    },
                 };
 
                 await InitApp.importModules({
@@ -256,6 +259,9 @@ module.exports = ({ expect }) => {
                     getManifest() {
                         return fakeManifest;
                     },
+                    getEnv(name) {
+                        return `${name}_fake`;
+                    },
                 };
                 await InitApp.importModules({
                     master,
@@ -400,6 +406,13 @@ module.exports = ({ expect }) => {
                 };
                 const master = {
                     setEnv() {},
+                    getEnv: (str) => {
+                        if (str === "importModulesFromNPM") {
+                            return ["fakeMod", "fakeMod2"];
+                        } else {
+                            return str + "_fake";
+                        }
+                    },
                     setApp(app) {
                         expect(app).to.be.instanceof(FakeApp);
                     },