@adaptivestone/framework 4.6.0 → 4.8.0

package/modules/Base.js

@@ -1,5 +1,4 @@
-const fs = require('node:fs').promises;
-const { join, normalize } = require('node:path');
+const { getFilesPathWithInheritance } = require('../helpers/files');
 
 class Base {
   #realLogger = null;
@@ -29,128 +28,18 @@ class Base {
 
   /**
    * Get winston loger for given label
-   * @param {sting} label name of logger
+   * @param {string} label name of logger
    */
   getLogger(label) {
-    // eslint-disable-next-line global-require
-    const winston = require('winston'); // speed up optimisation
-    const alignColorsAndTime = winston.format.combine(
-      winston.format.colorize({
-        all: true,
-      }),
-      winston.format.label({
-        label: ` \x1B[32m[${label}]\x1B[39m`,
-      }),
-      winston.format.timestamp(),
-      winston.format.printf(
-        (info) =>
-          `(${process.pid}) ${info.label}  ${info.timestamp}  ${info.level} : ${info.message}`,
-      ),
-    );
-
-    const logConfig = this.app.getConfig('log').transports;
-
-    function IsConstructor(f) {
-      try {
-        Reflect.construct(String, [], f);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    }
-    const transports = [];
-    for (const log of logConfig) {
-      if (log.enable) {
-        if (log.transport === 'console') {
-          transports.push(
-            new winston.transports.Console({
-              level: log.transportOptions.level,
-              format: winston.format.combine(
-                winston.format.colorize(),
-                alignColorsAndTime,
-              ),
-            }),
-          );
-        } else {
-          // eslint-disable-next-line global-require, import/no-dynamic-require
-          let Tr = require(log.transport);
-          if (!IsConstructor(Tr) && Tr.default) {
-            Tr = Tr.default;
-          } else {
-            // eslint-disable-next-line no-console
-            console.error(
-              `${log.transport} not a constructor. Please check it`,
-            );
-            // eslint-disable-next-line no-continue
-            continue;
-          }
-
-          transports.push(new Tr(log.transportOptions));
-        }
-      }
-    }
-
-    return winston.createLogger({
-      level: 'silly',
-      transports,
-    });
+    return this.app.logger.child({ label });
   }
 
   async getFilesPathWithInheritance(internalFolder, externalFolder) {
-    async function rreaddir(dir, allFiles = []) {
-      const files = (await fs.readdir(dir)).map((f) => join(dir, f));
-      allFiles.push(...files);
-      await Promise.all(
-        files.map(async (f) => {
-          if ((await fs.stat(f)).isDirectory()) {
-            allFiles.pop();
-            return rreaddir(f, allFiles);
-          }
-          return null;
-        }),
-      );
-      return allFiles.map((file) => file.replace(`${normalize(dir)}/`, ''));
-    }
-
-    let [internalFiles, externalFiles] = await Promise.all([
-      rreaddir(internalFolder),
-      rreaddir(externalFolder),
-    ]);
-
-    const filterIndexFile = (fileName) => {
-      const fileArray = fileName.split('/');
-      const file = fileArray[fileArray.length - 1];
-      return (
-        file[0] === file[0].toUpperCase() && // Start with capital
-        file[0] !== '.' && // not start with dot
-        !file.includes('.test.js') // not test files
-      );
-    };
-
-    internalFiles = internalFiles.filter(filterIndexFile);
-    externalFiles = externalFiles.filter(filterIndexFile);
-
-    const filesToLoad = [];
-    for (const file of internalFiles) {
-      if (externalFiles.includes(file)) {
-        this.logger.verbose(
-          `Skipping register INTERNAL file ${file} as it override by EXTERNAL ONE`,
-        );
-      } else {
-        filesToLoad.push({
-          path: `${internalFolder}/${file}`,
-          file,
-        });
-      }
-    }
-
-    for (const file of externalFiles) {
-      filesToLoad.push({
-        path: `${externalFolder}/${file}`,
-        file,
-      });
-    }
-    return filesToLoad;
+    return getFilesPathWithInheritance({
+      internalFolder,
+      externalFolder,
+      logger: (text) => this.logger.verbose(text),
+    });
   }
 
   /**

package/modules/BaseCli.js

@@ -47,12 +47,8 @@ class Cli extends Base {
       );
       return false;
     }
-    // TODO wait until https://github.com/nodejs/node/issues/35889
     const { default: Command } = await import(this.commands[command]);
 
-    // eslint-disable-next-line import/no-dynamic-require, global-require
-    // const Command = require(this.commands[command]);
-
     const c = new Command(this.app, this.commands, args);
     let result = false;
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "4.6.0",
+  "version": "4.8.0",
   "description": "Adaptive stone node js framework",
   "main": "index.js",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=18.17.0"
   },
   "repository": {
     "type": "git",

package/server.d.ts

@@ -7,6 +7,7 @@ import { Model as MongooseModel, Schema } from 'mongoose';
 
 import BaseCli from './modules/BaseCli';
 import Cache from './services/cache/Cache';
+import winston from 'winston';
 
 type ServerConfig = {
   folders: ExpandDeep<TFolderConfig>;
@@ -22,6 +23,7 @@ declare class Server {
     foldersConfig: Server['config']['folders'];
     events: EventEmitter;
     get cache(): Server['cacheService'];
+    get logger(): winston.Logger;
     httpServer: null;
     controllerManager: null;
   };
@@ -39,10 +41,16 @@ declare class Server {
   constructor(config: ExpandDeep<ServerConfig>);
 
   /**
-   * Start server (http + websocket + init all http and websocet ralated functions)
+   * Start server (http  + init all http ralated functions)
    */
   startServer(callbackBefore404?: Promise<null>): Promise<null>;
 
+  /**
+   * Do an initialization (config reading,  etc)
+   * @returns {Promise}
+   */
+  init(): Promise<boolean>;
+
   /**
    * Return config from {configName} (file name) on config folder.
    * Support cache and updating confing into cache
@@ -54,6 +62,11 @@ declare class Server {
    */
   getConfig(configName: string): {};
 
+  /**
+   * Return or create new logger instance. This is a main logger instance
+   */
+  getLogger(): winston.Logger;
+
   /**
    * Primary designed for tests when we need to update some configs before start testing
    * Should be called before any initialization was done

package/server.js

@@ -1,13 +1,23 @@
 /* eslint-disable no-console */
 const EventEmitter = require('node:events');
+const { hrtime } = require('node:process');
 
 require('dotenv').config();
 const merge = require('deepmerge');
+const winston = require('winston');
+const { getFilesPathWithInheritance } = require('./helpers/files');
+const { consoleLogger } = require('./helpers/logger');
+
+const Cache = require('./services/cache/Cache');
 
 /**
  * Main framework class.
  */
 class Server {
+  #realLogger = null;
+
+  #isInited = false;
+
   /**
    *  Construct new server
    * @param {Object} config main config object
@@ -33,6 +43,9 @@ class Server {
       get cache() {
         return that.getCache();
       },
+      get logger() {
+        return that.getLogger();
+      },
       httpServer: null,
       controllerManager: null,
     };
@@ -40,28 +53,23 @@ class Server {
     this.cache = {
       configs: new Map(),
       models: new Map(),
+      modelConstructors: new Map(),
     };
 
     this.cli = false;
   }
 
   /**
-   * Start server (http + websocket + init all http and websocet ralated functions)
+   * Start server (http  + init all http ralated functions)
    * @param <Promise>callbackBefore404 code that should be executed before adding page 404
    * @returns {Promise}
    */
   async startServer(callbackBefore404 = async () => Promise.resolve()) {
-    // eslint-disable-next-line global-require
-    // const HttpServer = require('./services/http/HttpServer');
-    // eslint-disable-next-line global-require
-    // const ControllerManager = require('./controllers/index');
-    // TODO wait until https://github.com/nodejs/node/issues/35889
     const [{ default: HttpServer }, { default: ControllerManager }] =
       await Promise.all([
-        // eslint-disable-next-line import/extensions
         import('./services/http/HttpServer.js'), // Speed optimisation
-        // eslint-disable-next-line import/extensions
         import('./controllers/index.js'), // Speed optimisation
+        this.init(),
       ]);
 
     this.addErrorHandling();
@@ -76,20 +84,115 @@ class Server {
     this.app.httpServer.add404Page();
   }
 
+  /**
+   * Do an initialization (config reading,  etc)
+   * @returns {Promise}
+   */
+  async init() {
+    if (this.#isInited) {
+      return true;
+    }
+
+    console.time('Server init. Done');
+    await Promise.all([this.#initConfigFiles(), this.#loadModelFiles()]);
+
+    this.#isInited = true;
+
+    console.timeEnd('Server init. Done');
+
+    return true;
+  }
+
+  async #initConfigFiles() {
+    const files = await getFilesPathWithInheritance({
+      internalFolder: `${__dirname}/config`,
+      externalFolder: this.app.foldersConfig.config,
+      loggerFileType: 'CONFIG',
+      logger: (m) => consoleLogger('info', m),
+      filter: {
+        startWithCapital: false,
+      },
+    });
+
+    const configFiles = {};
+
+    for (const file of files) {
+      const config = file.file.split('.');
+      if (!configFiles[config[0]]) {
+        configFiles[config[0]] = {};
+      }
+      if (config.length === 2) {
+        configFiles[config[0]].default = file.path;
+      } else {
+        configFiles[config[0]][config[1]] = file.path;
+      }
+    }
+
+    const loadConfig = async (configName, values) => {
+      const promises = [import(values.default)];
+      if (process.env.NODE_ENV && values[process.env.NODE_ENV]) {
+        promises.push(import(values[process.env.NODE_ENV]));
+      }
+      const result = await Promise.all(promises);
+      return {
+        name: configName,
+        finalValue: merge(result[0].default, result[1]?.default || {}, {
+          arrayMerge: (destinationArray, sourceArray) => sourceArray,
+        }),
+      };
+    };
+
+    const loadingPromises = [];
+
+    for (const [configFile, value] of Object.entries(configFiles)) {
+      loadingPromises.push(loadConfig(configFile, value));
+    }
+
+    const configs = await Promise.all(loadingPromises);
+
+    for (const config of configs) {
+      this.cache.configs.set(config.name, config.finalValue);
+    }
+    return true;
+  }
+
+  async #loadModelFiles() {
+    const files = await getFilesPathWithInheritance({
+      internalFolder: `${__dirname}/models`,
+      externalFolder: this.app.foldersConfig.models,
+      loggerFileType: 'MODEL',
+      logger: (m) => consoleLogger('info', m),
+    });
+
+    const promises = [];
+    for (const file of files) {
+      const t = hrtime.bigint();
+      promises.push(
+        import(file.path).then((f) => ({
+          name: file.file.split('.')[0],
+          file: f,
+          took: hrtime.bigint() - t,
+        })),
+      );
+    }
+
+    const loadedModels = await Promise.all(promises);
+
+    for (const model of loadedModels) {
+      this.cache.modelConstructors.set(model.name, model.file.default);
+    }
+    return true;
+  }
+
   /**
    * Add error logging on promise reject
    */
-  // eslint-disable-next-line class-methods-use-this
   addErrorHandling() {
-    process.on('uncaughtException', console.error);
-    process.on('unhandledRejection', (reason, p) => {
-      console.log(
-        'Possibly Unhandled Rejection at: Promise ',
-        p,
-        ' reason: ',
-        reason,
-      );
-      console.trace('unhandledRejection');
+    process.on('uncaughtException', (e) =>
+      this.app.logger.error('uncaughtException', e),
+    );
+    process.on('unhandledRejection', (e) => {
+      this.app.logger.error('unhandledRejection', e);
     });
   }
 
@@ -104,28 +207,93 @@ class Server {
    * @returns {Object} config object. Structure depends of config file
    */
   getConfig(configName) {
-    // const configName = name.charAt(0).toUpperCase() + name.slice(1);
+    if (!this.#isInited) {
+      throw new Error('You should call Server.init() before using it');
+    }
+
     if (!this.cache.configs.has(configName)) {
-      let envConfig = {};
-      if (process.env.NODE_ENV) {
-        envConfig =
-          this.getFileWithExtendingInhirence(
-            'config',
-            `${configName}.${process.env.NODE_ENV}.js`,
-          ) || envConfig;
-      }
-      this.cache.configs.set(
-        configName,
-        merge(
-          this.getFileWithExtendingInhirence('config', configName),
-          envConfig,
-          { arrayMerge: (destinationArray, sourceArray) => sourceArray },
-        ),
+      this.logger.warn(
+        `You asked for config ${configName} that not exists. Please check you codebase `,
       );
+      return {};
     }
     return this.cache.configs.get(configName);
   }
 
+  /**
+   * Return or create new logger instance. This is a main logger instance
+   */
+  getLogger() {
+    if (!this.#realLogger) {
+      this.#realLogger = this.#createLogger();
+    }
+    return this.#realLogger;
+  }
+
+  #createLogger() {
+    const alignColorsAndTime = winston.format.combine(
+      winston.format.colorize({
+        all: true,
+      }),
+      winston.format.timestamp(),
+      winston.format.printf(
+        (info) =>
+          `(${process.pid}) \x1B[32m[${info.label ?? 'SERVER'}]\x1B[39m ${
+            info.timestamp
+          }  ${info.level} : ${info.message} ${info?.stack ?? ''} ${
+            info.durationMs ? `Duration: ${info.durationMs}ms` : ''
+          }`,
+      ),
+    );
+    const logConfig = this.app.getConfig('log').transports;
+    function IsConstructor(f) {
+      try {
+        Reflect.construct(String, [], f);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    }
+
+    const logger = winston.createLogger({
+      format: winston.format.errors({ stack: true }),
+      level: 'silly',
+    });
+
+    for (const log of logConfig) {
+      if (log.enable) {
+        if (log.transport === 'console') {
+          logger.add(
+            new winston.transports.Console({
+              level: log.transportOptions.level,
+              format: winston.format.combine(
+                winston.format.colorize(),
+                alignColorsAndTime,
+              ),
+            }),
+          );
+        } else {
+          import(log.transport).then((Tr) => {
+            let Transport = Tr.default;
+            if (!IsConstructor(Transport) && Transport.default) {
+              Transport = Transport.default;
+            } else {
+              console.error(
+                `${log.transport} not a constructor. Please check it`,
+              );
+              return;
+            }
+            logger.profile(`Adding new logger ${log.transport}`);
+            logger.add(new Transport(log.transportOptions));
+            logger.profile(`Adding new logger ${log.transport}`);
+          });
+        }
+      }
+    }
+
+    return logger;
+  }
+
   /**
    * Primary designed for tests when we need to update some configs before start testing
    * Should be called before any initialization was done
@@ -149,14 +317,14 @@ class Server {
    */
   getModel(modelName) {
     if (modelName.endsWith('s')) {
-      console.warn(
+      this.app.logger.warn(
         `Probably your model name '${modelName}' in plural from. Try to avoid plural form`,
       );
     }
     if (!this.cache.models.has(modelName)) {
-      const Model = this.getFileWithExtendingInhirence('models', modelName);
+      const Model = this.cache.modelConstructors.get(modelName);
       if (!Model) {
-        console.error(`Model not found: ${modelName}`);
+        this.app.logger.error(`Model not found: ${modelName}`);
         return false;
       }
       try {
@@ -164,8 +332,8 @@ class Server {
 
         this.cache.models.set(modelName, model.mongooseModel);
       } catch (e) {
-        console.error(`Problem with model ${modelName}, ${e.message}`);
-        console.error(e);
+        this.app.logger.error(`Problem with model ${modelName}, ${e.message}`);
+        this.app.logger.error(e);
       }
     }
     return this.cache.models.get(modelName);
@@ -178,11 +346,7 @@ class Server {
    */
   async runCliCommand(commandName, args) {
     if (!this.cli) {
-      // eslint-disable-next-line import/extensions
-      // TODO wait until https://github.com/nodejs/node/issues/35889
-      // const { default: BaseCli } = await import('./modules/BaseCli.js'); // Speed optimisation
-      // eslint-disable-next-line global-require
-      const BaseCli = require('./modules/BaseCli');
+      const { default: BaseCli } = await import('./modules/BaseCli.js'); // Speed optimisation
       this.cli = new BaseCli(this);
     }
     return this.cli.run(commandName, args);
@@ -194,52 +358,10 @@ class Server {
    */
   getCache() {
     if (!this.cacheService) {
-      // eslint-disable-next-line global-require
-      const Cache = require('./services/cache/Cache'); // Speed optimisation
       this.cacheService = new Cache(this.app);
     }
     return this.cacheService;
   }
-
-  /**
-   * Get file using Inhirence (ability to overrite models, configs, etc)
-   * @param {('models'|'config')} fileType  type of file to load
-   * @param {string} fileName  name of file to load
-   */
-  getFileWithExtendingInhirence(fileType, fileName) {
-    let file;
-    try {
-      // eslint-disable-next-line global-require, import/no-dynamic-require
-      file = require(`${this.config.folders[fileType]}/${fileName}`);
-    } catch (e) {
-      try {
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        file = require(`./${fileType}/${fileName}`);
-      } catch (e2) {
-        const levels = [
-          'error',
-          'warn',
-          'info',
-          'http',
-          'verbose',
-          'debug',
-          'silly',
-        ];
-
-        if (
-          !process.env.LOGGER_CONSOLE_LEVEL ||
-          levels.indexOf(process.env.LOGGER_CONSOLE_LEVEL) > 0 // as a warn level
-        ) {
-          console.warn(
-            `Config not found '${fileName}'. This can be a normal (in case this an environment config)`,
-          );
-        }
-
-        file = false;
-      }
-    }
-    return file;
-  }
 }
 
 module.exports = Server;

package/services/cache/Cache.js

@@ -1,13 +1,17 @@
-const redis = require('redis');
 const Base = require('../../modules/Base');
 
 class Cache extends Base {
   constructor(app) {
+    super(app);
+    this.whenReady = this.#init();
+  }
+
+  async #init() {
     // todo for now only redis. refactor for drives support in future
     // at least memory and redis drivers should be presented
     // memory drives should works on master process level
     // we should support multiple cashe same time
-    super(app);
+    const redis = await import('redis');
     const conf = this.app.getConfig('redis');
     this.redisClient = redis.createClient({
       url: conf.url,
@@ -33,6 +37,7 @@ class Cache extends Base {
   }
 
   async getSetValue(keyValue, onNotFound, storeTime = 60 * 5) {
+    await this.whenReady;
     if (!this.redisClient.isOpen) {
       await this.redisClient.connect();
     }
@@ -58,9 +63,7 @@ class Cache extends Base {
       try {
         result = await onNotFound();
       } catch (e) {
-        this.logger.error(
-          `Cache onNotFound for key '${key}' error: ${e.message}`,
-        );
+        this.logger.error(`Cache onNotFound for key '${key}' error: ${e}`);
         this.promiseMapping.delete(key);
         reject(e);
         return Promise.reject(e);
@@ -100,6 +103,8 @@ class Cache extends Base {
   }
 
   async removeKey(keyValue) {
+    await this.whenReady;
+
     if (!this.redisClient.isOpen) {
       await this.redisClient.connect();
     }