@adaptivestone/framework 5.0.0-alpha.9 → 5.0.0-beta.1

package/services/http/middleware/GetUserByToken.js

@@ -5,13 +5,14 @@ class GetUserByToken extends AbstractMiddleware {
     return 'Grab a token and try to parse the user from it. It user exist will add req.appInfo.user variable';
   }
 
+  // eslint-disable-next-line class-methods-use-this
   get usedAuthParameters() {
     return [
       {
         name: 'Authorization',
         type: 'apiKey',
         in: 'header',
-        description: this.constructor.description,
+        description: GetUserByToken.description,
       },
     ];
   }
@@ -21,7 +22,7 @@ class GetUserByToken extends AbstractMiddleware {
       this.logger.warn('You call GetUserByToken more then once');
       return next();
     }
-    let { token } = req.body;
+    let { token } = req.body || {};
     this.logger.verbose(
       `GetUserByToken token in BODY ${token}. Token in Authorization header ${req.get(
         'Authorization',

package/services/http/middleware/I18n.js

@@ -1,37 +1,36 @@
 import i18next from 'i18next';
 import BackendFS from 'i18next-fs-backend';
-import Backend from 'i18next-chained-backend';
 import AbstractMiddleware from './AbstractMiddleware.js';
 
 class I18n extends AbstractMiddleware {
+  cache = {};
+
+  enabled = true;
+
+  lookupQuerystring = '';
+
+  supportedLngs = [];
+
+  fallbackLng = 'en';
+
+  /** @type {i18next} */
+  i18n = {
+    // @ts-ignore
+    t: (text) => text,
+    language: 'en',
+  };
+
   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({
+      i18next.use(BackendFS).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`,
-            },
-          ],
+          loadPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.json`,
+          addPath: `${this.app.foldersConfig.locales}/{{lng}}/{{ns}}.missing.json`,
         },
         fallbackLng: I18NConfig.fallbackLng,
         preload: I18NConfig.preload,
@@ -64,7 +63,7 @@ class I18n extends AbstractMiddleware {
 
       if (!this.cache[lang]) {
         this.cache[lang] = i18next.cloneInstance({
-          initImmediate: false,
+          initAsync: false,
           lng: lang,
         });
       }

package/services/http/middleware/IpDetector.js

@@ -0,0 +1,59 @@
+import { BlockList } from 'node:net';
+
+import AbstractMiddleware from './AbstractMiddleware.js';
+
+class IpDetector extends AbstractMiddleware {
+  static get description() {
+    return 'Detect real user IP address. Support proxy and load balancer';
+  }
+
+  constructor(app, params) {
+    super(app, params);
+    const { trustedProxy } = this.app.getConfig('ipDetector');
+
+    this.blockList = new BlockList();
+
+    for (const subnet of trustedProxy) {
+      const addressType = subnet.includes(':') ? 'ipv6' : 'ipv4';
+      if (subnet.includes('/')) {
+        // CIDR
+        const [realSubnet, prefixLength] = subnet.split('/');
+        this.blockList.addSubnet(
+          realSubnet,
+          parseInt(prefixLength, 10),
+          addressType,
+        );
+      } else if (subnet.includes('-')) {
+        // RANGE
+        const [start, end] = subnet.split('-');
+        this.blockList.addRange(start, end, addressType);
+      } else {
+        // just an address
+        this.blockList.addAddress(subnet, addressType);
+      }
+    }
+  }
+
+  async middleware(req, res, next) {
+    const { headers } = this.app.getConfig('ipDetector');
+    const initialIp = req.socket.remoteAddress;
+    req.appInfo.ip = initialIp;
+    const addressType = initialIp.includes(':') ? 'ipv6' : 'ipv4';
+
+    if (this.blockList.check(initialIp, addressType)) {
+      // we can trust this source
+      for (const header of headers) {
+        // in a range
+        const ipHeader = req.headers[header.toLowerCase()];
+        if (ipHeader) {
+          const [firstIp] = ipHeader.split(',').map((ip) => ip.trim());
+          req.appInfo.ip = firstIp;
+          break;
+        }
+      }
+    }
+    next();
+  }
+}
+
+export default IpDetector;

package/services/http/middleware/Pagination.js

@@ -19,8 +19,9 @@ class Pagination extends AbstractMiddleware {
   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;
+    limit = (typeof limit !== 'number' ? parseInt(limit, 10) : limit) || 10;
+    maxLimit =
+      (typeof maxLimit !== 'number' ? parseInt(maxLimit, 10) : maxLimit) || 100;
 
     req.appInfo.pagination = {};
     req.appInfo.pagination.page =

package/services/http/middleware/RateLimiter.js

@@ -78,10 +78,16 @@ class RateLimiter extends AbstractMiddleware {
 
     const key = [];
     if (ip) {
-      key.push(req.ip);
+      if (!req.appInfo.ip) {
+        this.logger.error(
+          `RateLimiter: Can't get remote address from request. Please check that you used IpDetecor middleware before RateLimiter`,
+        );
+      } else {
+        key.push(req.appInfo.ip);
+      }
     }
     if (route) {
-      key.push(req.originalUrl);
+      key.push(`${req.baseUrl ?? ''}${req.path ?? ''}`); // to avoid quesry params
     }
     if (user && req.appInfo?.user) {
       key.push(req.appInfo?.user.id);

package/services/http/middleware/RequestLogger.js

@@ -6,13 +6,13 @@ class RequestLogger extends AbstractMiddleware {
   }
 
   async middleware(req, res, next) {
-    const startTime = Date.now();
+    const startTime = performance.now();
     const text = `Request is  [${req.method}] ${req.url}`;
     this.logger.info(text);
     res.on('finish', () => {
-      const duration = Date.now() - startTime;
+      const end = performance.now();
       this.logger.info(
-        `Finished ${text}. Status: ${res.statusCode}. Duration ${duration} ms`,
+        `Finished ${text}. Status: ${res.statusCode}.  [${(end - startTime).toFixed(2)} ms]`,
       );
     });
     next();

package/services/http/middleware/RequestParser.js

@@ -29,7 +29,7 @@ class RequestParser extends AbstractMiddleware {
 
     req.body = {
       // todo avoid body in next versions
-      ...req.body,
+      ...(req.body || {}),
       ...fields,
       ...files,
     };

package/services/validate/ValidateService.js

@@ -26,7 +26,7 @@ class ValidateService extends Base {
     );
   }
 
-  static getDriverByValidatorBody(app, body) {
+  static getDriverByValidatorBody(app, body = {}) {
     if (this.isValidatorExists(body)) {
       return body;
     }

package/.eslintrc.cjs

@@ -1,41 +0,0 @@
-module.exports = {
-  env: {
-    es2023: true,
-    node: true,
-  },
-  extends: ['airbnb-base', 'prettier'],
-  plugins: ['prettier'],
-  parserOptions: {
-    ecmaVersion: 2023,
-  },
-  rules: {
-    'no-restricted-syntax': [
-      'error',
-      {
-        selector: 'ForInStatement',
-        message:
-          'for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array.',
-      },
-      {
-        selector: 'LabeledStatement',
-        message:
-          'Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand.',
-      },
-      {
-        selector: 'WithStatement',
-        message:
-          '`with` is disallowed in strict mode because it makes code impossible to predict and optimize.',
-      },
-    ],
-    'prettier/prettier': 'error',
-    'import/extensions': 'off', // it have a problem with dynamic imports
-    'import/prefer-default-export': 'off', // we want to have signgke default export too
-  },
-  overrides: [
-    {
-      files: ['**/*.test.js'],
-      extends: ['plugin:vitest/all', 'plugin:vitest/recommended'],
-      plugins: ['vitest'],
-    },
-  ],
-};

package/commands/Generate.js

@@ -1,14 +0,0 @@
-import AbstractCommand from '../modules/AbstractCommand.js';
-
-class Generate extends AbstractCommand {
-  async run() {
-    if (!this.args.type) {
-      this.logger.error('Please provide type to generate "--type=model');
-
-      return false;
-    }
-    return true;
-  }
-}
-
-export default Generate;