@adaptivestone/framework 2.15.4 → 3.0.1

package/modules/AbstractController.js

@@ -1,15 +1,15 @@
+/* eslint-disable array-callback-return */
 /* eslint-disable no-restricted-syntax */
 /* eslint-disable guard-for-in */
 const express = require('express');
-const validator = require('validator');
+const merge = require('deepmerge');
 
 const Base = require('./Base');
-const PrepareAppInfo = require('../services/http/middleware/PrepareAppInfo');
 const GetUserByToken = require('../services/http/middleware/GetUserByToken');
 const Auth = require('../services/http/middleware/Auth');
 
 /**
- * Abstract controller. You shoul extend any controller from them.
+ * Abstract controller. You should extend any controller from them.
  * Place you cintroller into controller folder and it be inited in auto way.
  * By default name of route will be controller name not file name. But please name it in same ways.
  * You can overwrite base controllers byt creating controllers with tha same file name (yes file name, not class name)
@@ -22,66 +22,108 @@ class AbstractController extends Base {
     this.prefix = prefix;
     this.router = express.Router();
     const { routes } = this;
-
     const expressPath = this.getExpressPath();
 
-    const middlewaresInfo = [];
+    /**
+     * Grab route middleware onlo one Map
+     */
+    const routeMiddlewares = new Map();
+    Object.entries(routes).forEach(([method, methodRoutes]) => {
+      Object.entries(methodRoutes).forEach(([route, routeParam]) => {
+        if (routeParam?.middleware) {
+          const fullRoute = method.toUpperCase() + route;
 
-    // eslint-disable-next-line prefer-const
-    for (let [path, middleware] of this.constructor.middleware) {
-      if (!Array.isArray(middleware)) {
-        middleware = [middleware];
-      }
-      for (const M of middleware) {
-        let method = 'all';
-        let realPath = path;
-        if (typeof realPath !== 'string') {
-          this.logger.error(`Path not a string ${realPath}. Please check it`);
-          // eslint-disable-next-line no-continue
-          continue;
+          if (!routeMiddlewares.has(fullRoute)) {
+            routeMiddlewares.set(fullRoute, []);
+          }
+
+          routeMiddlewares.set(fullRoute, [
+            ...routeMiddlewares.get(fullRoute),
+            ...routeParam.middleware,
+          ]);
         }
-        if (!realPath.startsWith('/')) {
-          method = realPath.split('/')[0]?.toLowerCase();
-          if (!method) {
-            this.logger.error(`Method not found for ${realPath}`);
+      });
+    });
+
+    /**
+     * Parse middlewares to be an object.
+     */
+    const parseMiddlewares = (middlewareMap) => {
+      const middlewaresInfo = [];
+      // eslint-disable-next-line prefer-const
+      for (let [path, middleware] of middlewareMap) {
+        if (!Array.isArray(middleware)) {
+          middleware = [middleware];
+        }
+        for (const M of middleware) {
+          let method = 'all';
+          let realPath = path;
+          if (typeof realPath !== 'string') {
+            this.logger.error(`Path not a string ${realPath}. Please check it`);
             // eslint-disable-next-line no-continue
             continue;
           }
-          realPath = realPath.substring(method.length);
-        }
-        if (typeof this.router[method] !== 'function') {
-          this.logger.error(
-            `Method ${method} not exist for middleware. Please check your codebase`,
-          );
-          // eslint-disable-next-line no-continue
-          continue;
-        }
-        const fullPath = `/${expressPath}/${realPath.toUpperCase()}`
-          .split('//')
-          .join('/')
-          .split('//')
-          .join('/');
-        let MiddlewareFunction = M;
-        let middlewareParams = {};
-        if (Array.isArray(M)) {
-          [MiddlewareFunction, middlewareParams] = M;
+          if (!realPath.startsWith('/')) {
+            method = realPath.split('/')[0]?.toLowerCase();
+            if (!method) {
+              this.logger.error(`Method not found for ${realPath}`);
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+            realPath = realPath.substring(method.length);
+          }
+          if (typeof this.router[method] !== 'function') {
+            this.logger.error(
+              `Method ${method} not exist for middleware. Please check your codebase`,
+            );
+            // eslint-disable-next-line no-continue
+            continue;
+          }
+          const fullPath = `/${expressPath}/${realPath.toUpperCase()}`
+            .split('//')
+            .join('/')
+            .split('//')
+            .join('/');
+          let MiddlewareFunction = M;
+          let middlewareParams = {};
+          if (Array.isArray(M)) {
+            [MiddlewareFunction, middlewareParams] = M;
+          }
+          middlewaresInfo.push({
+            name: MiddlewareFunction.name,
+            method,
+            path: realPath,
+            fullPath,
+            params: middlewareParams,
+            MiddlewareFunction,
+          });
         }
-        middlewaresInfo.push({
-          name: M.name,
-          method: method.toUpperCase(),
-          path: realPath,
-          fullPath,
-        });
-
-        this.router[method](
-          realPath,
-          new MiddlewareFunction(this.app, middlewareParams).getMiddleware(),
-        );
       }
-    }
+      return middlewaresInfo;
+    };
+
+    const routeMiddlewaresReg = parseMiddlewares(routeMiddlewares);
+    const middlewaresInfo = parseMiddlewares(this.constructor.middleware);
 
     const routesInfo = [];
+    let routeObjectClone = {};
+
+    /**
+     *  Register controller middleware
+     */
+    for (const middleware of middlewaresInfo) {
+      this.router[middleware.method](
+        middleware.path,
+        new middleware.MiddlewareFunction(
+          this.app,
+          middleware.params,
+        ).getMiddleware(),
+      );
+    }
 
+    /**
+     *  Register routes itself
+     */
     for (const verb in routes) {
       if (typeof this.router[verb] !== 'function') {
         this.logger.error(
@@ -91,20 +133,18 @@ class AbstractController extends Base {
         continue;
       }
       for (const path in routes[verb]) {
+        const routeAdditionalMiddlewares = routeMiddlewaresReg.filter(
+          (middleware) => middleware.path === path,
+        );
         let routeObject = routes[verb][path];
+        routeObjectClone = merge({}, routeObject);
         if (Object.prototype.toString.call(routeObject) !== '[object Object]') {
           routeObject = {
             handler: routeObject,
             request: null,
+            middleware: null,
           };
 
-          if (typeof routeObject.handler === 'string') {
-            routeObject.handler = this[routeObject];
-            this.logger.warn(
-              'Using string as a controller callback deprecated. Please use function instead',
-            );
-          }
-
           if (typeof routeObject.handler !== 'function') {
             this.logger.error(
               `Can't resolve function '${
@@ -137,166 +177,175 @@ class AbstractController extends Base {
         //   `Controller '${this.getConstructorName()}' register function '${fnName}'  for method '${verb}' and path '${path}' Full path '${fullPath}'`,
         // );
 
-        this.router[verb](path, async (req, res, next) => {
-          if (routeObject.request) {
-            if (typeof routeObject.request.validate !== 'function') {
-              this.logger.error('request.validate should be a function');
-            }
-            if (typeof routeObject.request.cast !== 'function') {
-              this.logger.error('request.cast should be a function');
-            }
+        let additionalMiddlewares;
+
+        if (routeAdditionalMiddlewares.length > 0) {
+          additionalMiddlewares = Array.from(
+            routeAdditionalMiddlewares,
+            ({ MiddlewareFunction, params }) =>
+              new MiddlewareFunction(this.app, params).getMiddleware(),
+          );
+        }
+
+        this.router[verb](
+          path,
+          additionalMiddlewares || [],
+          async (req, res, next) => {
+            if (routeObject.request) {
+              if (typeof routeObject.request.validate !== 'function') {
+                this.logger.error('request.validate should be a function');
+              }
+              if (typeof routeObject.request.cast !== 'function') {
+                this.logger.error('request.cast should be a function');
+              }
+              const bodyAndQuery = merge(req.query, req.body);
+
+              try {
+                await routeObject.request.validate(bodyAndQuery);
+              } catch (e) {
+                let { errors } = e;
+                // translate it
+                if (req.i18n) {
+                  errors = e.errors.map((err) => req.i18n.t(err));
+                }
+                this.logger.error(`Request validation failed: ${errors}`);
 
-            try {
-              await routeObject.request.validate(req.body);
-            } catch (e) {
-              // translate it
-              const errors = e.errors.map((err) => req.i18n.t(err));
-              this.logger.error(`Request validation failed: ${errors}`);
-
-              return res.status(400).json({
-                errors: {
-                  [e.path]: errors,
-                },
+                return res.status(400).json({
+                  errors: {
+                    [e.path]: errors,
+                  },
+                });
+              }
+              req.appInfo.request = routeObject.request.cast(bodyAndQuery, {
+                stripUnknown: true,
               });
             }
-            req.appInfo.request = routeObject.request.cast(req.body, {
-              stripUnknown: true,
+            req.body = new Proxy(req.body, {
+              get: (target, prop) => {
+                this.logger.warn(
+                  'Please not use "req.body" directly. Implement "request" and use "req.appInfo.request" ',
+                );
+                return target[prop];
+              },
             });
-          }
-          req.body = new Proxy(req.body, {
-            get: (target, prop) => {
-              this.logger.warn(
-                'Please not use "req.body" directly. Implement "request" and use "req.appInfo.request" ',
-              );
-              return target[prop];
-            },
-          });
 
-          if (routeObject.handler.constructor.name !== 'AsyncFunction') {
-            const error =
-              "Handler should be AsyncFunction. Perhabs you miss 'async' of function declaration?";
-            this.logger.error(error);
-            return res.status(500).json({
-              succes: false,
-              message: 'Platform error. Please check later or contact support',
-            });
-          }
-          return routeObject.handler.call(this, req, res, next).catch((e) => {
-            this.logger.error(e.message);
-            console.error(e);
-            return res.status(500).json({
-              succes: false,
-              message: 'Platform error. Please check later or contact support',
+            if (routeObject.handler.constructor.name !== 'AsyncFunction') {
+              const error =
+                "Handler should be AsyncFunction. Perhabs you miss 'async' of function declaration?";
+              this.logger.error(error);
+              return res.status(500).json({
+                message:
+                  'Platform error. Please check later or contact support',
+              });
+            }
+            return routeObject.handler.call(this, req, res, next).catch((e) => {
+              this.logger.error(e.message);
+              console.error(e);
+              return res.status(500).json({
+                message:
+                  'Platform error. Please check later or contact support',
+              });
             });
-          });
-        });
+          },
+        );
       }
     }
 
-    const text = [
-      '',
-      `Controller '${this.getConstructorName()}' registered.`,
-      'Middlewares:',
-    ];
+    /**
+     * Generate text info
+     */
+    const text = ['', `Controller '${this.getConstructorName()}' registered.`];
 
-    middlewaresInfo.forEach((m) => {
-      text.push(
-        `Path:'${m.path}'. Full path: '${m.fullPath}'. Method: '${m.method}'. Function: '${m.name}'`,
-      );
-    });
-    text.push('Callbacks:');
+    const reports = {
+      'Middlewares:': middlewaresInfo,
+      'Route middlewares:': routeMiddlewaresReg,
+      'Callbacks:': routesInfo,
+    };
+    for (const key in reports) {
+      text.push(`${key}`);
+      for (const item of reports[key]) {
+        text.push(
+          `Path:'${item.path}'. Full path: '${
+            item.fullPath
+          }'. Method: '${item.method.toUpperCase()}'. Function: '${item.name}'`,
+        );
+      }
+    }
 
-    routesInfo.forEach((m) => {
-      text.push(
-        `Path:'${m.path}'. Full path: '${m.fullPath}'. Method: '${m.method}'. Callback: '${m.name}'`,
-      );
-    });
     text.push(`Time: ${Date.now() - time} ms`);
 
     this.logger.verbose(text.join('\n'));
 
-    this.app.httpServer.express.use(expressPath, this.router);
-  }
+    /**
+     * Generate documentation
+     */
+    if (!this.app.httpServer) {
+      const fields = [];
+      if (routeObjectClone.request) {
+        const reqFields = routeObjectClone.request.fields;
+        const entries = Object.entries(reqFields);
+        entries.forEach(([key, value]) => {
+          const field = {};
+          field.name = key;
+          field.type = value.type;
+          if (value.exclusiveTests) {
+            field.isRequired = value.exclusiveTests.required;
+          }
 
-  /**
-   * Internal validation method for params validation.
-   * You can pass own function or use validator.js functions
-   * From own function you can return a bool then will be treater as rule pass or not. At that case error message will be used from default error. But you also can provide error as output. Where only one arrya element will be an error message
-   * @param {object} obj object with params to validate
-   * @param {object} rules validation rules. rule name should match parameter name
-   * @deprecated
-   * @example
-   * // We can pass own function
-   * validate({
-   *      someKey:10
-   *    },{
-   *      'someKey':[
-   *        (val)=>val>10,
-   *        'Error message'
-   *      ]
-   *    })
-   * @example
-   * // We can pass function to validator.js
-   *  validate({
-   *      someKey: 'test_at_test.com'
-   *    },{
-   *      'someKey':[
-   *        'isEmail',
-   *        'Please provide valid email'
-   *      ]
-   *    })
-   * @example
-   * // We can pass function to validator.js with params
-   *  validate({
-   *      someKey: 'test_at_test.com'
-   *    },{
-   *      'someKey':[
-   *        ['isEmail',{'require_tld':false}],
-   *        'Please provide valid email'
-   *      ]
-   *    })
-   */
-  validate(obj, rules) {
-    this.logger.warn(
-      'Validate deprecated. Please do not use it. Will be revomed it future release',
-    );
-    const errors = {};
-    for (const name in rules) {
-      let validationResult = false;
-      if (typeof rules[name][0] === 'function') {
-        validationResult = rules[name][0](obj[name]);
-        if (
-          Object.prototype.toString.call(validationResult) === '[object Array]'
-        ) {
-          [errors[name]] = validationResult;
-          validationResult = false;
-        }
-      } else if (typeof validator[rules[name][0]] === 'function') {
-        // use from validator then
-        validationResult = validator[rules[name][0]](obj[name]);
-      } else if (
-        Object.prototype.toString.call(rules[name][0]) === '[object Array]' &&
-        typeof validator[rules[name][0][0]] === 'function'
-      ) {
-        // use from validator then
-        validationResult = validator[rules[name][0][0]](
-          `${obj[name]}`,
-          rules[name][0][1],
-        );
-      } else {
-        this.logger.warn(
-          `No rule found for ${name}. Swith to existing checking`,
-        );
-        validationResult = !!obj[name];
-      }
-      if (!validationResult && !errors[name]) {
-        [, errors[name]] = rules[name];
+          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);
+        });
       }
+
+      this.app.documentation.push({
+        contollerName: this.getConstructorName(),
+        routesInfo: routesInfo.map((route) => ({
+          [route.fullPath]: {
+            method: route.method,
+            name: route.name,
+            fields,
+            routeMiddlewares: routeMiddlewaresReg
+              // eslint-disable-next-line consistent-return
+              .map((middleware) => {
+                if (
+                  route.fullPath.toUpperCase() ===
+                  middleware.fullPath.toUpperCase()
+                ) {
+                  return {
+                    name: middleware.name,
+                    params: middleware.params,
+                  };
+                }
+              })
+              .filter(Boolean),
+            controllerMiddlewares: [
+              ...new Set(
+                middlewaresInfo
+                  .filter(
+                    (middleware) =>
+                      middleware.fullPath.toUpperCase() ===
+                      route.fullPath.toUpperCase(),
+                  )
+                  .map(({ name, params }) => ({ name, params })),
+              ),
+            ],
+          },
+        })),
+      });
+    } else {
+      this.app.httpServer.express.use(expressPath, this.router);
     }
-    if (Object.entries(errors).length === 0 && errors.constructor === Object) {
-      return false;
-    }
-    return errors;
   }
 
   /**
@@ -306,24 +355,14 @@ class AbstractController extends Base {
    * Be default path apply to ANY' method, but you can preattach 'METHOD' into patch to scope patch to this METHOD
    * @example
    * return new Map([
-   *    ['/*', [PrepareAppInfo, GetUserByToken]] // for any method for this controller
+   *    ['/*', [GetUserByToken]] // for any method for this controller
    *    ['POST/', [Auth]] // for POST method
    *    ['/superSecretMethod', [OnlySuperSecretUsers]] // route with ANY method
    *    ['PUT/superSecretMathod', [OnlySuperSecretAdmin]] // route with PUT method
    * ]);
    */
   static get middleware() {
-    return new Map([['/*', [PrepareAppInfo, GetUserByToken, Auth]]]);
-  }
-
-  /**
-   * Part of abstract contorller.
-   * When you do not need controller name to append in route then return false here.
-   * Useful for home(root) controllers
-   * @deprecated please use getExpressPath instead
-   */
-  static get isUseControllerNameForRouting() {
-    return true;
+    return new Map([['/*', [GetUserByToken, Auth]]]);
   }
 
   /**
@@ -342,12 +381,6 @@ class AbstractController extends Base {
    * Get express path with inheritance of path
    */
   getExpressPath() {
-    if (!this.constructor.isUseControllerNameForRouting) {
-      console.warn(
-        'isUseControllerNameForRouting is DEPRECATED. Please use getExpressPath instead',
-      );
-      return '/';
-    }
     return `/${this.getConstructorName().toLowerCase()}`.replace('//', '/');
   }
 

package/modules/AbstractModel.js

@@ -20,28 +20,21 @@ class AbstractModel extends Base {
     );
     if (!mongoose.connection.readyState) {
       // do not connect on test
-      mongoose
-        .connect(this.app.getConfig('mongo').connectionString, {
-          useNewUrlParser: true,
-          useCreateIndex: true,
-          useUnifiedTopology: true,
-          useFindAndModify: false,
-        })
-        .then(
-          () => {
-            this.logger.info('Mongo connection success');
-            this.app.events.on('die', async () => {
-              for (const c of mongoose.connections) {
-                c.close(true);
-              }
-              // await mongoose.disconnect(); // TODO it have problems with replica-set
-            });
-            callback();
-          },
-          (error) => {
-            this.logger.error("Can't install mongodb connection", error);
-          },
-        );
+      mongoose.connect(this.app.getConfig('mongo').connectionString, {}).then(
+        () => {
+          this.logger.info('Mongo connection success');
+          this.app.events.on('die', async () => {
+            for (const c of mongoose.connections) {
+              c.close(true);
+            }
+            // await mongoose.disconnect(); // TODO it have problems with replica-set
+          });
+          callback();
+        },
+        (error) => {
+          this.logger.error("Can't install mongodb connection", error);
+        },
+      );
     } else {
       callback();
     }

package/modules/Base.d.ts

@@ -0,0 +1,36 @@
+import winston from 'winston';
+import Server from '../server';
+
+declare class Base {
+  app: Server['app'];
+  _realLogger: null;
+
+  constructor(app: Server['app']);
+
+  /**
+   * In case of logging sometimes we might need to replace name
+   */
+  getConstructorName(): string;
+
+  /**
+   * Optimzation to lazy load logger. It will be inited only on request
+   */
+  get logger(): winston.Logger;
+
+  /**
+   * Get winston loger for given label
+   * @param label name of logger
+   */
+  getLogger(label: string): winston.Logger;
+
+  getFilesPathWithInheritance(
+    internalFolder: string,
+    externalFolder: string,
+  ): Promise<string[]>;
+
+  /**
+   * Return logger group. Just to have all logs groupped logically
+   */
+  static get loggerGroup(): string;
+}
+export = Base;

package/modules/Base.js

@@ -3,9 +3,6 @@ const fs = require('fs').promises;
 const { join } = require('path');
 
 class Base {
-  /**
-   * @param {import('../Server')} app  //TODO change to *.d.ts as this is a Server, not app
-   */
   constructor(app) {
     this.app = app;
     this._realLogger = null;
@@ -98,15 +95,6 @@ class Base {
     });
   }
 
-  async loadFilesWithInheritance(internalFolder, externalFolder) {
-    this.logger.warn(
-      'Method "loadFilesWithInheritance" deprecated. Please use "getFilesPathWithInheritance"',
-    );
-    return (
-      await this.getFilesPathWithInheritance(internalFolder, externalFolder)
-    ).map((file) => file.path);
-  }
-
   async getFilesPathWithInheritance(internalFolder, externalFolder) {
     async function rreaddir(dir, allFiles = []) {
       const files = (await fs.readdir(dir)).map((f) => join(dir, f));