@adaptivestone/framework 4.7.0 → 4.8.0

package/server.js

@@ -1,9 +1,14 @@
 /* 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.
@@ -11,6 +16,8 @@ const winston = require('winston');
 class Server {
   #realLogger = null;
 
+  #isInited = false;
+
   /**
    *  Construct new server
    * @param {Object} config main config object
@@ -46,6 +53,7 @@ class Server {
     this.cache = {
       configs: new Map(),
       models: new Map(),
+      modelConstructors: new Map(),
     };
 
     this.cli = false;
@@ -57,13 +65,11 @@ class Server {
    * @returns {Promise}
    */
   async startServer(callbackBefore404 = async () => Promise.resolve()) {
-    // const HttpServer = require('./services/http/HttpServer');
-    // const ControllerManager = require('./controllers/index');
-    // TODO wait until https://github.com/nodejs/node/issues/35889
     const [{ default: HttpServer }, { default: ControllerManager }] =
       await Promise.all([
         import('./services/http/HttpServer.js'), // Speed optimisation
         import('./controllers/index.js'), // Speed optimisation
+        this.init(),
       ]);
 
     this.addErrorHandling();
@@ -78,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);
     });
   }
 
@@ -106,24 +207,15 @@ 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);
   }
@@ -225,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 {
@@ -240,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);
@@ -254,9 +346,7 @@ class Server {
    */
   async runCliCommand(commandName, args) {
     if (!this.cli) {
-      // TODO wait until https://github.com/nodejs/node/issues/35889
       const { default: BaseCli } = await import('./modules/BaseCli.js'); // Speed optimisation
-      // const BaseCli = require('./modules/BaseCli');
       this.cli = new BaseCli(this);
     }
     return this.cli.run(commandName, args);
@@ -268,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();
     }

package/services/cache/Cache.test.js

@@ -0,0 +1,81 @@
+import { describe, it, expect } from 'vitest';
+import { setTimeout } from 'node:timers/promises';
+
+describe('cache', () => {
+  const time = Date.now();
+
+  it('can get set values', async () => {
+    expect.assertions(2);
+
+    const { cache } = global.server.app;
+
+    const res = await cache.getSetValue('TEST_TIME', () => time);
+    expect(res).toStrictEqual(time);
+
+    const res2 = await cache.getSetValue('TEST_TIME', () => '123');
+    expect(res2).toStrictEqual(time);
+  });
+
+  it('can delete values', async () => {
+    expect.assertions(1);
+    const { cache } = global.server.app;
+
+    await cache.removeKey('TEST_TIME');
+
+    const res2 = await cache.getSetValue('TEST_TIME', () => '123');
+    expect(res2).toBe('123');
+  });
+
+  it('can works with big int', async () => {
+    expect.assertions(2);
+    const { cache } = global.server.app;
+
+    const res = await cache.getSetValue('BIN_INT', () => 1n);
+    expect(res).toBe(1n);
+
+    const res2 = await cache.getSetValue('BIN_INT', () => '1111');
+    expect(res2).toBe(1n);
+  });
+
+  it('can execute only one request per time', async () => {
+    expect.assertions(3);
+    const { cache } = global.server.app;
+    let counter = 0;
+
+    const f = async () => {
+      await setTimeout(10);
+      counter += 1;
+      return 1;
+    };
+
+    const [res, res1] = await Promise.all([
+      cache.getSetValue('T', f),
+      cache.getSetValue('T', f),
+    ]);
+
+    expect(counter).toBe(1);
+
+    expect(res).toBe(1);
+    expect(res1).toBe(1);
+  });
+
+  it('can handle problems on onNotFound', async () => {
+    expect.assertions(1);
+    const getAsyncThrow = async () => {
+      throw new Error('err');
+    };
+    let err;
+
+    const { cache } = global.server.app;
+
+    try {
+      await Promise.all([
+        cache.getSetValue('THROW', getAsyncThrow),
+        cache.getSetValue('THROW', getAsyncThrow),
+      ]);
+    } catch (e) {
+      err = e;
+    }
+    expect(err.message).toBe('err');
+  });
+});

package/services/http/middleware/Auth.test.js

@@ -0,0 +1,57 @@
+import { beforeAll, describe, it, expect } from 'vitest';
+import Auth from './Auth';
+
+describe('atuh middleware methods', () => {
+  let middleware;
+  beforeAll(() => {
+    middleware = new Auth(global.server.app);
+  });
+  it('have description fields', async () => {
+    expect.assertions(1);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('middleware pass when user presented', async () => {
+    expect.assertions(1);
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {
+        user: true,
+      },
+    };
+    await middleware.middleware(req, {}, nextFunction);
+    expect(isCalled).toBeTruthy();
+  });
+
+  it('middleware NOT pass when user NOT presented', async () => {
+    expect.assertions(3);
+    let isCalled = false;
+    let status;
+    let isSend;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {}, // no user
+    };
+    await middleware.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        json() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(isCalled).toBeFalsy();
+    expect(status).toBe(401);
+    expect(isSend).toBeTruthy();
+  });
+});

package/services/http/middleware/I18n.test.js

@@ -12,7 +12,7 @@ describe('i18n middleware methods', () => {
   });
 
   it('detectors should works correctly', async () => {
-    expect.assertions(5);
+    expect.assertions(6);
     const request = {
       get: () => 'en',
       query: {
@@ -42,10 +42,13 @@ describe('i18n middleware methods', () => {
     };
     lang = await middleware.detectLang(request);
     expect(lang).toBe('en');
+
+    lang = await middleware.detectLang(request, false);
+    expect(lang).toBe('en-GB');
   });
 
   it('middleware that works', async () => {
-    expect.assertions(4);
+    expect.assertions(6);
     let isCalled = false;
     const nextFunction = () => {
       isCalled = true;
@@ -55,10 +58,19 @@ describe('i18n middleware methods', () => {
       appInfo: {},
     };
     await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBe(true);
+    expect(isCalled).toBeTruthy();
     expect(req.appInfo.i18n).toBeDefined();
+    expect(req.appInfo.i18n.language).toBe('en');
     expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
     expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
+
+    const req2 = {
+      get: () => 'fakeLang',
+      appInfo: {},
+    };
+
+    await middleware.middleware(req2, {}, nextFunction);
+    expect(req2.appInfo.i18n.language).toBe('en');
   });
 
   it('middleware disabled', async () => {

package/services/http/middleware/PrepareAppInfo.test.js

@@ -17,7 +17,7 @@ describe('prepareAppInfo methods', () => {
     };
     const req = {};
     await middleware.middleware(req, {}, nextFunction);
-    expect(isCalled).toBe(true);
+    expect(isCalled).toBeTruthy();
     expect(req.appInfo).toBeDefined();
     req.appInfo.test = 5;
     await middleware.middleware(req, {}, nextFunction);

package/services/http/middleware/Role.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest';
+import Role from './Role';
+
+describe('role middleware methods', () => {
+  it('have description fields', async () => {
+    expect.assertions(1);
+    const middleware = new Role(global.server.app);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('middleware pass when user presented with a right role', async () => {
+    expect.assertions(1);
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {
+        user: {
+          roles: ['role1', 'role2'],
+        },
+      },
+    };
+    const middleware = new Role(global.server.app, {
+      roles: ['admin', 'role1'],
+    });
+
+    await middleware.middleware(req, {}, nextFunction);
+    expect(isCalled).toBeTruthy();
+  });
+
+  it('middleware NOT pass when user NOT presented', async () => {
+    expect.assertions(3);
+    let isCalled = false;
+    let status;
+    let isSend;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {}, // no user
+    };
+    const middleware = new Role(global.server.app);
+    await middleware.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        send() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(isCalled).toBeFalsy();
+    expect(status).toBe(401);
+    expect(isSend).toBeTruthy();
+  });
+
+  it('middleware NOT pass when user  have a wrong role', async () => {
+    expect.assertions(3);
+    let isCalled = false;
+    let status;
+    let isSend;
+    const nextFunction = () => {
+      isCalled = true;
+    };
+    const req = {
+      appInfo: {
+        user: { roles: ['role1', 'role2'] },
+      },
+    };
+    const middleware = new Role(global.server.app, { roles: ['admin'] });
+    await middleware.middleware(
+      req,
+      {
+        status(statusCode) {
+          status = statusCode;
+          return this;
+        },
+        json() {
+          isSend = true;
+        },
+      },
+      nextFunction,
+    );
+    expect(isCalled).toBeFalsy();
+    expect(status).toBe(403);
+    expect(isSend).toBeTruthy();
+  });
+});

package/tests/setup.js

@@ -38,6 +38,7 @@ beforeAll(async () => {
         process.env.TEST_FOLDER_MIGRATIONS || path.resolve('./migrations'),
     },
   });
+  await global.server.init();
   global.server.updateConfig('mongo', {
     connectionString: connectionStringMongo,
   });

package/tests/setupVitest.js

@@ -40,6 +40,7 @@ beforeAll(async () => {
         process.env.TEST_FOLDER_MIGRATIONS || path.resolve('./migrations'),
     },
   });
+  await global.server.init();
   global.server.updateConfig('mongo', {
     connectionString: connectionStringMongo,
   });