@adaptivestone/framework 3.4.2 → 4.0.0

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(

package/services/http/middleware/I18n.js

@@ -0,0 +1,119 @@
+const i18next = require('i18next');
+const BackendFS = require('i18next-fs-backend');
+const Backend = require('i18next-chained-backend');
+
+const AbstractMiddleware = require('./AbstractMiddleware');
+
+class I18n extends AbstractMiddleware {
+  constructor(app, params) {
+    super(app, params);
+    const I18NConfig = this.app.getConfig('i18n');
+    this.i18n = {
+      t: (text) => text,
+      language: I18NConfig.fallbackLng,
+    };
+    this.cache = {};
+
+    if (I18NConfig.enabled) {
+      this.logger.info('Enabling i18n support');
+      this.i18n = i18next;
+      i18next.use(Backend).init({
+        backend: {
+          backends: [
+            BackendFS,
+            //  BackendFS,
+          ],
+          backendOptions: [
+            // {
+            //  loadPath: __dirname + '/../../locales/{{lng}}/{{ns}}.json',
+            //   addPath: __dirname + '/../../locales/{{lng}}/{{ns}}.missing.json'
+            // },
+            {
+              loadPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.json`,
+              addPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.missing.json`,
+            },
+          ],
+        },
+        fallbackLng: I18NConfig.fallbackLng,
+        preload: I18NConfig.preload,
+        saveMissing: I18NConfig.saveMissing,
+        debug: I18NConfig.debug,
+      });
+    }
+
+    this.enabled = I18NConfig.enabled;
+    this.lookupQuerystring = I18NConfig.lookupQuerystring;
+    this.supportedLngs = I18NConfig.supportedLngs;
+    this.fallbackLng = I18NConfig.fallbackLng;
+  }
+
+  static get description() {
+    return 'Provide language detection and translation';
+  }
+
+  async middleware(req, res, next) {
+    let i18n;
+
+    if (this.enabled) {
+      let lang = this.detectLang(req);
+      if (!lang || this.supportedLngs.indexOf(lang) === -1) {
+        this.logger.verbose(
+          `Language "${lang}" is not supported or not detected. Using fallback on ${this.fallbackLng}`,
+        );
+        lang = this.fallbackLng;
+      }
+
+      if (!this.cache[lang]) {
+        this.cache[lang] = i18next.cloneInstance({
+          initImmediate: false,
+          lng: lang,
+        });
+      }
+      i18n = this.cache[lang];
+    }
+
+    if (!i18n) {
+      i18n = this.i18n;
+    }
+
+    req.appInfo.i18n = i18n;
+    req.i18n = new Proxy(req.appInfo.i18n, {
+      get: (target, prop) => {
+        this.logger.warn('Please not use "req.i18n" Use "req.appInfo.i18n"');
+        return target[prop];
+      },
+    });
+
+    return next();
+  }
+
+  detectors = {
+    XLang: (req) => req.get('X-Lang'), // grab from header
+    query: (req) => (req.query ? req.query[this.lookupQuerystring] : false), // grab from query
+    user: (req) => req.appInfo?.user?.locale, // what if we have a user and user have a defined locale?
+  };
+
+  detectorOrder = ['XLang', 'query', 'user'];
+
+  detectLang(req, isUseShortCode = true) {
+    let lang = '';
+    for (const detectorName of this.detectorOrder) {
+      const lng = this.detectors[detectorName](req);
+      if (!lng) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+      if (i18next.services.languageUtils.isSupportedCode(lng)) {
+        if (isUseShortCode) {
+          lang = i18next.services.languageUtils.getLanguagePartFromCode(lng);
+        } else {
+          lang = lng;
+        }
+        break;
+      }
+    }
+    return lang;
+  }
+}
+
+module.exports = I18n;

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

@@ -0,0 +1,77 @@
+const I18n = require('./I18n');
+
+describe('i18n middleware methods', () => {
+  let middleware;
+  beforeAll(() => {
+    middleware = new I18n(global.server.app);
+  });
+  it('have description fields', async () => {
+    expect.assertions(1);
+    expect(middleware.constructor.description).toBeDefined();
+  });
+
+  it('detectors should works correctly', async () => {
+    expect.assertions(5);
+    const request = {
+      get: () => 'en',
+      query: {
+        [middleware.lookupQuerystring]: 'es',
+      },
+    };
+    let lang = await middleware.detectLang(request);
+    expect(lang).toBe('en');
+
+    request.appInfo = {
+      user: {
+        locale: 'be',
+      },
+    };
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('en');
+    request.get = () => null;
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('es');
+
+    delete request.query;
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('be');
+
+    request.query = {
+      [middleware.lookupQuerystring]: 'en-GB',
+    };
+    lang = await middleware.detectLang(request);
+    expect(lang).toBe('en');
+  });
+
+  it('middleware that works', async () => {
+    expect.assertions(4);
+    const nextFunction = jest.fn(() => {});
+    const req = {
+      get: () => 'en',
+      appInfo: {},
+    };
+    await middleware.middleware(req, {}, nextFunction);
+    expect(nextFunction).toHaveBeenCalledWith();
+    expect(req.appInfo.i18n).toBeDefined();
+    expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
+    expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
+  });
+
+  it('middleware disabled', async () => {
+    expect.assertions(4);
+    global.server.app.updateConfig('i18n', { enabled: false });
+    middleware = new I18n(global.server.app);
+
+    const nextFunction = jest.fn(() => {});
+    const req = {
+      get: () => 'en',
+      appInfo: {},
+    };
+    await middleware.middleware(req, {}, nextFunction);
+    expect(nextFunction).toHaveBeenCalledWith();
+    expect(req.appInfo.i18n).toBeDefined();
+    expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
+    expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
+    global.server.app.updateConfig('i18n', { enabled: true });
+  });
+});

package/services/http/middleware/Pagination.js

@@ -0,0 +1,56 @@
+const yup = require('yup');
+const AbstractMiddleware = require('./AbstractMiddleware');
+/**
+ * Middleware for reusing pagination
+ */
+class Pagination extends AbstractMiddleware {
+  static get description() {
+    return 'Pagination middleware. You can use limit=10 and maxLimit=100 parameters';
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  get relatedQueryParameters() {
+    return yup.object().shape({
+      page: yup.number(),
+      limit: yup.number(),
+    });
+  }
+
+  async middleware(req, res, next) {
+    let { limit, maxLimit } = this.params;
+
+    limit = typeof limit === 'number' ? parseInt(limit, 10) : 10;
+    maxLimit = typeof maxLimit === 'number' ? parseInt(maxLimit, 10) : 100;
+
+    req.appInfo.pagination = {};
+    req.appInfo.pagination.page =
+      typeof req?.query?.page === 'string'
+        ? parseInt(req?.query?.page, 10) || 1
+        : 1;
+
+    req.appInfo.pagination.limit =
+      typeof req?.query?.limit === 'string'
+        ? parseInt(req?.query?.limit, 10) || 0
+        : limit;
+
+    if (req.appInfo.pagination.limit > maxLimit) {
+      req.appInfo.pagination.limit = maxLimit;
+    }
+
+    if (req.appInfo.pagination.page < 1) {
+      req.appInfo.pagination.page = 1;
+    }
+
+    if (req.appInfo.pagination.limit < 0) {
+      req.appInfo.pagination.limit = 0;
+    }
+
+    req.appInfo.pagination.skip =
+      req.appInfo.pagination.page * req.appInfo.pagination.limit -
+      req.appInfo.pagination.limit;
+
+    return next();
+  }
+}
+
+module.exports = Pagination;