@adaptivestone/framework 3.4.3 → 4.0.0

package/modules/AbstractController.js

@@ -1,19 +1,17 @@
-/* eslint-disable array-callback-return */
 /* eslint-disable no-restricted-syntax */
 /* eslint-disable guard-for-in */
 const express = require('express');
-const merge = require('deepmerge');
-
 const Base = require('./Base');
 const GetUserByToken = require('../services/http/middleware/GetUserByToken');
 const Auth = require('../services/http/middleware/Auth');
-
+const ValidateService = require('../services/validate/ValidateService');
+const DocumentationGenerator = require('../services/documentation/DocumentationGenerator');
 /**
  * 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)
- * In most cases you will want to have a 'home' route that not include controller name. For this case please check 'getExpressPath'
+ * In most cases you will want to have a 'home' route that not include controller name. For this case please check '  getHttpPath'
  */
 class AbstractController extends Base {
   constructor(app, prefix, isExpressMergeParams = false) {
@@ -24,7 +22,14 @@ class AbstractController extends Base {
       mergeParams: isExpressMergeParams,
     });
     const { routes } = this;
-    const expressPath = this.getExpressPath();
+    let httpPath = this.getHttpPath();
+
+    if (this.getExpressPath) {
+      this.logger.warn(
+        `getExpressPath deprecated. Please use getHttpPath instead. Will be removed on v5`,
+      );
+      httpPath = this.getExpressPath();
+    }
 
     /**
      * Grab route middleware onlo one Map
@@ -47,69 +52,15 @@ class AbstractController extends Base {
       });
     });
 
-    /**
-     * 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;
-          }
-          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,
-            authParams: new MiddlewareFunction(this.app, middlewareParams)
-              ?.usedAuthParameters,
-            MiddlewareFunction,
-          });
-        }
-      }
-      return middlewaresInfo;
-    };
-
-    const routeMiddlewaresReg = parseMiddlewares(routeMiddlewares);
+    const routeMiddlewaresReg = this.parseMiddlewares(
+      routeMiddlewares,
+      httpPath,
+    );
+    const middlewaresInfo = this.parseMiddlewares(
+      this.constructor.middleware,
+      httpPath,
+    );
 
-    const middlewaresInfo = parseMiddlewares(this.constructor.middleware);
     const routesInfo = [];
 
     /**
@@ -141,11 +92,13 @@ class AbstractController extends Base {
           (middleware) =>
             middleware.path === path && middleware.method === verb,
         );
+
         let routeObject = routes[verb][path];
         if (Object.prototype.toString.call(routeObject) !== '[object Object]') {
           routeObject = {
             handler: routeObject,
             request: null,
+            query: null,
             middleware: null,
           };
 
@@ -165,7 +118,7 @@ class AbstractController extends Base {
           fnName = fnName.name;
         }
 
-        const fullPath = `/${expressPath}/${path}`
+        const fullPath = `/${httpPath}/${path}`
           .split('//')
           .join('/')
           .split('//')
@@ -176,6 +129,7 @@ class AbstractController extends Base {
           description: routeObject?.description,
           method: verb.toUpperCase(),
           fields: routeObject?.request?.fields,
+          queryFields: routeObject?.query?.fields,
           path,
           fullPath,
         });
@@ -192,61 +146,51 @@ class AbstractController extends Base {
               new MiddlewareFunction(this.app, params).getMiddleware(),
           );
         }
-        const { controllerValidationAbortEarly } =
-          this.app.getConfig('validate');
+
         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, {
-                  abortEarly: controllerValidationAbortEarly,
-                  req,
-                });
-              } catch (e) {
-                let { errors } = e;
-                // translate it
-                if (req.i18n && errors) {
-                  errors = errors.map((err) => req.i18n.t(err));
-                }
-                this.logger.error(
-                  `Request validation failed with message: ${e.message}. errors: ${errors}`,
-                );
-
-                const errorAnswer = {};
-                if (!e.inner || !e.inner.length) {
-                  errorAnswer[e.path] = errors;
-                } else {
-                  e.inner.forEach((err) => {
-                    errorAnswer[err.path] = err.errors;
-                    if (req.i18n && err.errors) {
-                      errorAnswer[err.path] = err.errors.map((err1) =>
-                        req.i18n.t(err1),
-                      );
-                    }
-                  });
-                }
-
-                return res.status(400).json({
-                  errors: errorAnswer,
-                });
-              }
-              req.appInfo.request = await routeObject.request.cast(
-                bodyAndQuery,
-                {
-                  stripUnknown: true,
-                  req,
+            const requestObj = {
+              query: req.query,
+              body: req.body,
+              appInfo: req.appInfo,
+            };
+            try {
+              req.appInfo.request = await new ValidateService(
+                this.app,
+                routeObject?.request,
+              ).validateReqData(requestObj, {
+                selectedReqData: req.body,
+                additionalMiddlewareFieldsData: {
+                  middlewaresInfo,
+                  routeMiddlewaresReg,
+                  options: {
+                    method: verb,
+                    path: fullPath,
+                    prefix: 'request',
+                  },
                 },
-              );
+              });
+              req.appInfo.query = await new ValidateService(
+                this.app,
+                routeObject?.query,
+              ).validateReqData(requestObj, {
+                selectedReqData: req.query,
+                additionalMiddlewareFieldsData: {
+                  middlewaresInfo,
+                  routeMiddlewaresReg,
+                  options: {
+                    method: verb,
+                    path: fullPath,
+                    prefix: 'query',
+                  },
+                },
+              });
+            } catch (err) {
+              return res.status(400).json({
+                errors: err.message,
+              });
             }
             req.body = new Proxy(req.body, {
               get: (target, prop) => {
@@ -256,6 +200,14 @@ class AbstractController extends Base {
                 return target[prop];
               },
             });
+            req.query = new Proxy(req.query, {
+              get: (target, prop) => {
+                this.logger.warn(
+                  'Please not use "req.query" directly. Implement "query" and use "req.appInfo.query" ',
+                );
+                return target[prop];
+              },
+            });
 
             if (!routeObject.handler) {
               this.logger.error(`Route object have no handler defined`);
@@ -276,6 +228,7 @@ class AbstractController extends Base {
             }
             return routeObject.handler.call(this, req, res, next).catch((e) => {
               this.logger.error(e.message);
+              // eslint-disable-next-line no-console
               console.error(e);
               return res.status(500).json({
                 message:
@@ -311,104 +264,87 @@ class AbstractController extends Base {
     text.push(`Time: ${Date.now() - time} ms`);
 
     this.logger.verbose(text.join('\n'));
+    this.loadedTime = Date.now() - time;
 
     /**
      * Generate documentation
      */
+    if (!this.app.httpServer) {
+      this.app.documentation.push(
+        DocumentationGenerator.convertDataToDocumentationElement(
+          this.getConstructorName(),
+          routesInfo,
+          middlewaresInfo,
+          routeMiddlewaresReg,
+        ),
+      );
+    } else {
+      this.app.httpServer.express.use(httpPath, this.router);
+    }
+  }
 
-    const processingFields = (fieldsByRoute) => {
-      const fields = [];
-      if (!fieldsByRoute) {
-        return fields;
+  /**
+   * Parse middlewares to be an object.
+   */
+  parseMiddlewares(middlewareMap, httpPath) {
+    const middlewaresInfo = [];
+    // eslint-disable-next-line prefer-const
+    for (let [path, middleware] of middlewareMap) {
+      if (!Array.isArray(middleware)) {
+        middleware = [middleware];
       }
-      const entries = Object.entries(fieldsByRoute);
-      entries.forEach(([key, value]) => {
-        const field = {};
-        field.name = key;
-        field.type = value.type;
-        if (value.exclusiveTests) {
-          field.isRequired = value.exclusiveTests.required;
+      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 (value?.innerType) {
-          field.innerType = value?.innerType?.type;
+        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 (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,
-            });
-          });
+        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 = `/${httpPath}/${realPath.toUpperCase()}`
+          .split('//')
+          .join('/')
+          .split('//')
+          .join('/');
+        let MiddlewareFunction = M;
+        let middlewareParams = {};
+        if (Array.isArray(M)) {
+          [MiddlewareFunction, middlewareParams] = M;
         }
-        fields.push(field);
-      });
-      return fields;
-    };
-
-    if (!this.app.httpServer) {
-      this.app.documentation.push({
-        contollerName: this.getConstructorName(),
-        routesInfo: routesInfo.map((route) => ({
-          [route.fullPath]: {
-            method: route.method,
-            name: route.name,
-            description: route?.description,
-            fields: processingFields(route.fields),
-            routeMiddlewares: routeMiddlewaresReg
-              // eslint-disable-next-line consistent-return
-              .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,
-                  };
-                }
-              })
-              .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,
-                  })),
-              ),
-            ],
-          },
-        })),
-      });
-    } else {
-      this.app.httpServer.express.use(expressPath, this.router);
+        middlewaresInfo.push({
+          name: MiddlewareFunction.name,
+          method,
+          path: realPath,
+          fullPath,
+          params: middlewareParams,
+          relatedQueryParameters: new MiddlewareFunction(
+            this.app,
+            middlewareParams,
+          )?.relatedQueryParameters,
+          authParams: new MiddlewareFunction(this.app, middlewareParams)
+            ?.usedAuthParameters,
+          MiddlewareFunction,
+        });
+      }
     }
+    return middlewaresInfo;
   }
 
   /**
@@ -460,9 +396,9 @@ class AbstractController extends Base {
   }
 
   /**
-   * Get express path with inheritance of path
+   * Get http path with inheritance of path
    */
-  getExpressPath() {
+  getHttpPath() {
     return `/${this.getConstructorName().toLowerCase()}`.replace('//', '/');
   }
 

package/modules/AbstractModel.js

@@ -3,12 +3,13 @@ const Base = require('./Base');
 
 class AbstractModel extends Base {
   /**
-   * @param {import('../Server')} app  //TODO change to *.d.ts as this is a Server, not app
+   * @param {import('../server')} app  //TODO change to *.d.ts as this is a Server, not app
    * @param function callback optional callback when connection ready
    */
   constructor(app, callback = () => {}) {
     super(app);
     this.mongooseSchema = mongoose.Schema(this.modelSchema);
+    mongoose.set('strictQuery', true);
     this.mongooseSchema.set('timestamps', true);
     this.mongooseSchema.set('minimize', false);
     this.mongooseSchema.loadClass(this.constructor);

package/modules/Base.js

@@ -1,5 +1,5 @@
-const fs = require('fs').promises;
-const { join, normalize } = require('path');
+const fs = require('node:fs').promises;
+const { join, normalize } = require('node:path');
 
 class Base {
   #realLogger = null;
@@ -77,6 +77,7 @@ class Base {
           if (!IsConstructor(Tr) && Tr.default) {
             Tr = Tr.default;
           } else {
+            // eslint-disable-next-line no-console
             console.error(
               `${log.transport} not a constructor. Please check it`,
             );

package/modules/BaseCli.js

@@ -1,4 +1,5 @@
-const path = require('path');
+/* eslint-disable no-console */
+const path = require('node:path');
 const Base = require('./Base');
 
 class Cli extends Base {
@@ -46,9 +47,12 @@ class Cli extends Base {
       );
       return false;
     }
+    // TODO wait until https://github.com/nodejs/node/issues/35889
+    // const { default: Command } = await import(this.commands[command]);
 
-    // eslint-disable-next-line global-require, import/no-dynamic-require
+    // eslint-disable-next-line import/no-dynamic-require, global-require
     const Command = require(this.commands[command]);
+
     const c = new Command(this.app, this.commands, args);
     let result = false;
 

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "3.4.3",
+  "version": "4.0.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-plugin-jest": "^27.0.0",
     "husky": "^8.0.0",
     "jest": "^29.0.0",
     "lint-staged": "^13.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);
     }