@adaptivestone/framework 3.4.3 → 4.1.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "3.4.3",
+  "version": "4.1.0",
   "description": "Adaptive stone node js framework",
-  "main": "src/index.js",
+  "main": "index.js",
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "repository": {
     "type": "git",
@@ -15,9 +15,14 @@
     "dev": "nodemon ./index.js",
     "prod": "nodemon ./cluster.js",
     "test": "jest --coverage=true",
-    "codestyle": "prettier --check '**/*.(js|jsx|ts|tsx|json|css|scss|md)'",
+    "prettier": "prettier --check '**/*.(js|jsx|ts|tsx|json|css|scss|md)'",
+    "lint": "eslint '**/*.js'",
+    "lint:fix": "eslint '**/*.js' --fix",
+    "codestyle": "npm run prettier && npm run lint",
     "prepare": "husky install",
-    "cli": "node cliCommand"
+    "cli": "node cliCommand",
+    "benchmark": "h2load -n 10000 -c 50 -p 'http/1.1' http://localhost:3300/",
+    "benchmark2": "h2load -n 10000 -c 50  https://localhost:3300/"
   },
   "jest": {
     "setupFilesAfterEnv": [
@@ -34,18 +39,18 @@
   "author": "Andrey Logunov",
   "license": "MIT",
   "dependencies": {
-    "bcrypt": "^5.0.1",
     "cors": "^2.8.5",
     "deepmerge": "^4.2.2",
     "dotenv": "^16.0.0",
-    "email-templates": "^10.0.0",
     "express": "^4.17.1",
-    "i18next": "^22.0.4",
+    "formidable": "^2.1.1",
+    "html-to-text": "^9.0.3",
+    "i18next": "^23.2.8",
     "i18next-chained-backend": "^4.0.0",
     "i18next-fs-backend": "^2.0.0",
-    "i18next-http-middleware": "^3.1.4",
+    "juice": "^9.0.0",
     "minimist": "^1.2.5",
-    "mongoose": "^6.0.0",
+    "mongoose": "^7.0.0",
     "nodemailer": "^6.6.3",
     "nodemailer-sendmail-transport": "^1.0.2",
     "nodemailer-stub-transport": "^1.1.0",
@@ -54,20 +59,19 @@
     "redis": "^4.3.1",
     "winston": "^3.3.3",
     "winston-transport-sentry-node": "^2.0.0",
-    "yup": "^0.32.9"
+    "yup": "^1.0.0"
   },
   "devDependencies": {
     "eslint": "^8.0.0",
     "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.23.4",
+    "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-jest": "^27.0.0",
     "husky": "^8.0.0",
     "jest": "^29.0.0",
-    "lint-staged": "^13.0.0",
+    "lint-staged": "^14.0.0",
     "mongodb-memory-server": "^8.0.2",
-    "nodemon": "^2.0.12",
-    "prettier": "^2.3.2",
+    "nodemon": "^3.0.1",
+    "prettier": "^3.0.0",
     "supertest": "^6.1.4"
   },
   "lint-staged": {

package/server.d.ts

@@ -19,7 +19,7 @@ declare class Server {
     getModel: Server['getModel'];
     runCliCommand: Server['runCliCommand'];
     updateConfig: Server['updateConfig'];
-    foldersConfig: Server['config'];
+    foldersConfig: Server['config']['folders'];
     events: EventEmitter;
     get cache(): Server['cacheService'];
     httpServer: null;

package/server.js

@@ -1,7 +1,8 @@
-/* eslint-disable global-require */
+/* eslint-disable no-console */
+const EventEmitter = require('node:events');
+
 require('dotenv').config();
 const merge = require('deepmerge');
-const EventEmitter = require('events');
 
 /**
  * Main framework class.
@@ -50,16 +51,27 @@ class Server {
    * @returns {Promise}
    */
   async startServer(callbackBefore404 = async () => Promise.resolve()) {
-    const HttpServer = require('./services/http/HttpServer'); // Speed optimisation
-    const ControllerManager = require('./controllers/index'); // Speed optimisation
+    // 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.addErrorHandling();
 
     // TODO config
-    this.app.httpServer = new HttpServer(this.app, this.config);
+    this.app.httpServer = new HttpServer(this.app);
 
     this.app.controllerManager = new ControllerManager(this.app);
 
-    await this.app.controllerManager.initControllers(this.config);
+    await this.app.controllerManager.initControllers();
     await callbackBefore404();
     this.app.httpServer.add404Page();
   }
@@ -70,7 +82,7 @@ class Server {
   // eslint-disable-next-line class-methods-use-this
   addErrorHandling() {
     process.on('uncaughtException', console.error);
-    process.on('unhandledRejection', function (reason, p) {
+    process.on('unhandledRejection', (reason, p) => {
       console.log(
         'Possibly Unhandled Rejection at: Promise ',
         p,
@@ -166,7 +178,11 @@ class Server {
    */
   async runCliCommand(commandName, args) {
     if (!this.cli) {
-      const BaseCli = require('./modules/BaseCli'); // Speed optimisation
+      // 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');
       this.cli = new BaseCli(this);
     }
     return this.cli.run(commandName, args);
@@ -178,6 +194,7 @@ 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);
     }

package/services/cache/Cache.d.ts

@@ -11,7 +11,7 @@ declare class Cache extends Base {
    * Function return new key with added namespace
    * @param key key to add namespace
    */
-  getKeyWithNameSpace(key: String): String;
+  getKeyWithNameSpace(key: string): string;
 
   /**
    * Get value from cache. Set and get if not eists
@@ -20,7 +20,7 @@ declare class Cache extends Base {
    * @param storeTime how long we should store value on cache
    */
   getSetValue(
-    key: String,
+    key: string,
     onNotFound: () => Promise<any>,
     storeTime: number,
   ): Promise<any>;
@@ -29,7 +29,7 @@ declare class Cache extends Base {
    * Remove key from cache
    * @param key key to remove
    */
-  removeKey(key: String): Promise<number>;
+  removeKey(key: string): Promise<number>;
 }
 
 export = Cache;

package/services/cache/Cache.js

@@ -66,13 +66,27 @@ class Cache extends Base {
         return Promise.reject(e);
       }
 
-      this.redisClient.setEx(key, storeTime, JSON.stringify(result));
+      this.redisClient.setEx(
+        key,
+        storeTime,
+        JSON.stringify(result, (jsonkey, value) =>
+          typeof value === 'bigint' ? `${value}n` : value,
+        ),
+      );
     } else {
       this.logger.verbose(
-        `getSetValueFromCache FROM CACHE key ${key}, value ${result}`,
+        `getSetValueFromCache FROM CACHE key ${key}, value ${result.substring(
+          0,
+          100,
+        )}`,
       );
       try {
-        result = JSON.parse(result);
+        result = JSON.parse(result, (jsonkey, value) => {
+          if (typeof value === 'string' && /^\d+n$/.test(value)) {
+            return BigInt(value.slice(0, value.length - 1));
+          }
+          return value;
+        });
       } catch (e) {
         this.logger.warn(
           'Not able to parse json from redis cache. That can be a normal in case you store string here',

package/services/documentation/DocumentationGenerator.js

@@ -0,0 +1,171 @@
+const Base = require('../../modules/Base');
+const ValidateService = require('../validate/ValidateService');
+
+class DocumentationGenerator extends Base {
+  static processingFields(fieldsByRoute) {
+    const fields = [];
+    if (!fieldsByRoute) {
+      return fields;
+    }
+    const entries = Object.entries(fieldsByRoute);
+    entries.forEach(([key, value]) => {
+      const field = {};
+      field.name = key;
+      field.type = value.type;
+      if (value.exclusiveTests) {
+        field.required = value.exclusiveTests.required;
+      }
+      if (value?.innerType) {
+        field.innerType = value?.innerType?.type;
+      }
+
+      if (value.fields) {
+        field.fields = [];
+        // eslint-disable-next-line no-shadow
+        const entries = Object.entries(value.fields);
+        // eslint-disable-next-line no-shadow
+        entries.forEach(([key, value]) => {
+          field.fields.push({
+            name: key,
+            type: value.type,
+          });
+        });
+      }
+      fields.push(field);
+    });
+    return fields;
+  }
+
+  static selectUniqueFields(fields) {
+    return Array.from(
+      new Map(fields.map((item) => [item.name, item])).values(),
+    ).reduce((uniqueArray, item) => {
+      const existingItem = uniqueArray.find(
+        (uniqueItem) => uniqueItem.name === item.name,
+      );
+      if (!existingItem) {
+        uniqueArray.push(item);
+      } else if (item.required) {
+        existingItem.required = true;
+      }
+      return uniqueArray;
+    }, []);
+  }
+
+  static groupFieldsFromSchemas(schemas) {
+    const result = [];
+    schemas.forEach((schema) => {
+      const convertedSchema = new ValidateService(this.app, schema).validator;
+
+      for (const [key, value] of Object.entries(
+        convertedSchema?.fieldsInJsonFormat,
+      )) {
+        result.push({
+          name: key,
+          type: value.type,
+          required: value.required,
+        });
+      }
+    });
+
+    return result;
+  }
+
+  static convertDataToDocumentationElement(
+    controllerName,
+    routesInfo,
+    middlewaresInfo,
+    routeMiddlewaresReg,
+  ) {
+    return {
+      contollerName: controllerName,
+      routesInfo: routesInfo.map((route) => {
+        const middlewareQueryParams = ValidateService.getMiddlewareParams(
+          middlewaresInfo,
+          routeMiddlewaresReg,
+          {
+            method: route.method.toLowerCase(),
+            path: route.fullPath,
+          },
+        ).query;
+
+        const middlewareRequestParams = ValidateService.getMiddlewareParams(
+          middlewaresInfo,
+          routeMiddlewaresReg,
+          {
+            method: route.method.toLowerCase(),
+            path: route.fullPath,
+          },
+        ).request;
+
+        const queryParams = this.groupFieldsFromSchemas(middlewareQueryParams);
+
+        const requestParams = this.groupFieldsFromSchemas(
+          middlewareRequestParams,
+        );
+
+        return {
+          [route.fullPath]: {
+            method: route.method,
+            name: route.name,
+            description: route?.description,
+            fields: this.selectUniqueFields([
+              ...this.processingFields(route.fields),
+              ...requestParams,
+            ]),
+            queryFields: this.selectUniqueFields([
+              ...this.processingFields(route.queryFields),
+              ...queryParams,
+            ]),
+            routeMiddlewares: routeMiddlewaresReg
+              .map((middleware) => {
+                const routeFullPath = route.fullPath.toUpperCase();
+                const middlewareFullPath = middleware.fullPath.toUpperCase();
+                if (
+                  route.method.toLowerCase() ===
+                    middleware.method.toLowerCase() &&
+                  (middlewareFullPath === routeFullPath ||
+                    middlewareFullPath === `${routeFullPath}*`)
+                ) {
+                  return {
+                    name: middleware.name,
+                    params: middleware.params,
+                    authParams: middleware.authParams,
+                  };
+                }
+                return null;
+              })
+              .filter(Boolean),
+            controllerMiddlewares: [
+              ...new Set(
+                middlewaresInfo
+                  .filter((middleware) => {
+                    const routeFullPath = route.fullPath.toUpperCase();
+                    const middlewareFullPath =
+                      middleware.fullPath.toUpperCase();
+                    const middlewareFullPathWithSliced = middleware.fullPath
+                      .toUpperCase()
+                      .slice(0, -1);
+
+                    return (
+                      middlewareFullPath === routeFullPath ||
+                      middlewareFullPath === `${routeFullPath}*` ||
+                      routeFullPath?.indexOf(middlewareFullPathWithSliced) !==
+                        -1
+                    );
+                  })
+                  .map(({ name, params, authParams }) => ({
+                    name,
+                    params,
+                    authParams,
+                  })),
+              ),
+            ],
+          },
+        };
+      }),
+    };
+  }
+}
+
+module.exports = DocumentationGenerator;

package/services/http/HttpServer.js

@@ -1,13 +1,12 @@
+const http = require('node:http');
+const path = require('node:path');
 const express = require('express');
-const http = require('http');
-const path = require('path');
 const cors = require('cors');
 
-const i18next = require('i18next');
-const i18nextMiddleware = require('i18next-http-middleware');
-const BackendFS = require('i18next-fs-backend');
-const Backend = require('i18next-chained-backend');
+const RequestLoggerMiddleware = require('./middleware/RequestLogger');
+const I18nMiddleware = require('./middleware/I18n');
 const PrepareAppInfoMiddleware = require('./middleware/PrepareAppInfo');
+const RequestParserMiddleware = require('./middleware/RequestParser');
 
 const Base = require('../../modules/Base');
 
@@ -15,25 +14,19 @@ const Base = require('../../modules/Base');
  * HTTP server based on Express
  */
 class HttpServer extends Base {
-  constructor(app, folderConfig) {
+  constructor(app) {
     super(app);
     this.express = express();
+    this.express.disable('x-powered-by');
     this.express.set('views', [
-      folderConfig.folders.views,
+      this.app.foldersConfig.views,
       path.join(__dirname, '../../views'),
     ]);
     this.express.set('view engine', 'pug');
-    this.express.use((req, res, next) => {
-      const startTime = Date.now();
-      const text = `Request is  [${req.method}] ${req.url}`;
-      this.logger.info(text);
-      res.on('finish', () => {
-        const duration = Date.now() - startTime;
-        this.logger.info(`Finished ${text}. Duration ${duration} ms`);
-      });
-      next();
-    });
-    this.enableI18N(folderConfig);
+
+    this.express.use(new PrepareAppInfoMiddleware(this.app).getMiddleware());
+    this.express.use(new RequestLoggerMiddleware(this.app).getMiddleware());
+    this.express.use(new I18nMiddleware(this.app).getMiddleware());
 
     const httpConfig = this.app.getConfig('http');
     this.express.use(
@@ -41,17 +34,16 @@ class HttpServer extends Base {
         origin: httpConfig.corsDomains,
       }),
     ); // todo whitelist
-    this.express.use(express.urlencoded({ limit: '50mb', extended: true }));
-    this.express.use(express.json({ limit: '50mb' }));
-    this.express.use(express.static(folderConfig.folders.public));
+    this.express.use(express.static(this.app.foldersConfig.public));
     this.express.use(express.static('./public'));
 
-    this.express.use(new PrepareAppInfoMiddleware(this.app).getMiddleware());
+    this.express.use(new RequestParserMiddleware(this.app).getMiddleware());
 
     // As exprress will check numbersof arguments
     // eslint-disable-next-line no-unused-vars
     this.express.use((err, req, res, next) => {
       // error handling
+      // eslint-disable-next-line no-console
       console.error(err.stack);
       // TODO
       res.status(500).send('Something broke!');
@@ -79,85 +71,13 @@ class HttpServer extends Base {
     );
   }
 
-  /**
-   *  Enable support for i18n
-   * @param {object} folderConfig config
-   * @param {object} folderConfig.folders folder config
-   * @param {string} folderConfig.folders.config path to folder with config files
-   * @param {string} folderConfig.folders.models path to folder with moidels files
-   * @param {string} folderConfig.folders.controllers path to folder with controllers files
-   * @param {string} folderConfig.folders.views path to folder with view files
-   * @param {string} folderConfig.folders.public path to folder with public files
-   * @param {string} folderConfig.folders.locales path to folder with locales files
-   * @param {string} folderConfig.folders.emails path to folder with emails files
-   */
-  enableI18N(folderConfig) {
-    const I18NConfig = this.app.getConfig('i18n');
-    if (!I18NConfig.enabled) {
-      return;
-    }
-    const lngDetector = new i18nextMiddleware.LanguageDetector();
-    lngDetector.addDetector({
-      name: 'xLang',
-      // eslint-disable-next-line no-unused-vars
-      lookup: (req, res, options) => {
-        const lng = req.get('X-Lang');
-        if (lng) {
-          return lng;
-        }
-        return false;
-      },
-      // eslint-disable-next-line no-unused-vars
-      cacheUserLanguage: (req, res, lng, options) => {},
-    });
-    this.logger.info('Enabling i18n support');
-    i18next
-      .use(Backend)
-      .use(lngDetector)
-      .init({
-        backend: {
-          backends: [
-            BackendFS,
-            //  BackendFS,
-          ],
-          backendOptions: [
-            // {
-            //  loadPath: __dirname + '/../../locales/{{lng}}/{{ns}}.json',
-            //   addPath: __dirname + '/../../locales/{{lng}}/{{ns}}.missing.json'
-            // },
-            {
-              loadPath: `${folderConfig.folders.locales}/{{lng}}/{{ns}}.json`,
-              addPath: `${folderConfig.folders.locales}/{{lng}}/{{ns}}.missing.json`,
-            },
-          ],
-        },
-        fallbackLng: I18NConfig.fallbackLng,
-        preload: I18NConfig.preload,
-        saveMissing: I18NConfig.saveMissing,
-        debug: I18NConfig.debug,
-        detection: {
-          // caches: ['cookie'],
-          order: I18NConfig.langDetectionOders || ['xLang'],
-          lookupQuerystring: I18NConfig.lookupQuerystring,
-        },
-      });
-    this.express.use(i18nextMiddleware.handle(i18next));
-    this.express.use((req, res, next) => {
-      // f ix ru-Ru, en-US, etc
-      if (res.locals.language.length !== 2) {
-        [res.locals.language] = res.locals.language.split('-');
-      }
-      next();
-    });
-  }
-
   /**
    * Add handle for 404 error
    */
   add404Page() {
     this.express.use((req, res) => {
       // error handling
-      res.status(404).render('404');
+      res.status(404).json({ message: '404' });
     });
   }
 

package/services/http/middleware/AbstractMiddleware.js

@@ -1,3 +1,4 @@
+const yup = require('yup');
 const Base = require('../../../modules/Base');
 
 class AbstractMiddleware extends Base {
@@ -14,6 +15,25 @@ class AbstractMiddleware extends Base {
     return [];
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  get relatedQueryParameters() {
+    // For example  yup.object().shape({page: yup.number().required(),limit: yup.number()})
+    return yup.object().shape({});
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get relatedRequestParameters() {
+    // For example  yup.object().shape({page: yup.number().required(),limit: yup.number()})
+    return yup.object().shape({});
+  }
+
+  get relatedReqParameters() {
+    return {
+      request: this.relatedRequestParameters,
+      query: this.relatedQueryParameters,
+    };
+  }
+
   async middleware(req, res, next) {
     this.logger.warn('Middleware is not implemented');
     next();

package/services/http/middleware/GetUserByToken.js

@@ -17,6 +17,10 @@ class GetUserByToken extends AbstractMiddleware {
   }
 
   async middleware(req, res, next) {
+    if (req.appInfo.user) {
+      this.logger.warn('You call GetUserByToken more then once');
+      return next();
+    }
     let { token } = req.body;
     this.logger.verbose(
       `GetUserByToken token in BODY ${token}. Token if Authorization header ${req.get(