@adaptivestone/framework 3.4.3 → 4.1.0

package/models/User.test.js

@@ -22,7 +22,7 @@ describe('user model', () => {
     const user = await global.server.app.getModel('User').findOne({
       email: userEmail,
     });
-    expect(user.password !== userPassword).toBe(true);
+    expect(user.password).not.toBe(userPassword);
   });
 
   it('passwords should not be changed on other fields save', async () => {
@@ -32,22 +32,74 @@ describe('user model', () => {
     });
     const psw = user.password;
     user.email = 'rrrr';
-    user.save();
+    await user.save();
+    user.email = userEmail;
+    await user.save();
 
-    expect(user.password === psw).toBe(true);
+    expect(user.password).toBe(psw);
   });
 
-  describe('getUserByVerificationToken', () => {
+  describe('getUserByEmailAndPassword', () => {
+    it('should WORK with valid creds', async () => {
+      expect.assertions(1);
+      const userModel = await global.server.app.getModel('User');
+      const user = await userModel.getUserByEmailAndPassword(
+        userEmail,
+        userPassword,
+      );
+      expect(user.id).toBe(globalUser.id);
+    });
+
+    it('should NOT with INvalid creds', async () => {
+      expect.assertions(1);
+      const userModel = await global.server.app.getModel('User');
+      const user = await userModel.getUserByEmailAndPassword(
+        userEmail,
+        'wrongPassword',
+      );
+      expect(user).toBe(false);
+    });
+
+    it('should NOT with wrong email', async () => {
+      expect.assertions(1);
+      const userModel = await global.server.app.getModel('User');
+      const user = await userModel.getUserByEmailAndPassword(
+        'not@exists.com',
+        userPassword,
+      );
+      expect(user).toBe(false);
+    });
+  });
+
+  describe('getUserByToken', () => {
     it('should NOT work for non valid token', async () => {
-      expect.assertions(2);
+      expect.assertions(1);
+
+      const user = await global.server.app
+        .getModel('User')
+        .getUserByToken('fake one');
+      expect(user).toBe(false);
+    });
 
+    it('should  work for VALID token', async () => {
+      expect.assertions(1);
+      const token = await globalUser.generateToken();
       const user = await global.server.app
         .getModel('User')
-        .getUserByVerificationToken('fake one')
-        .catch((e) => {
-          expect(e).toBeDefined();
-        });
-      expect(user).toBeUndefined();
+        .getUserByToken(token.token);
+      expect(user.id).toBe(globalUser.id);
+    });
+  });
+
+  describe('getUserByVerificationToken', () => {
+    it('should NOT work for non valid token', async () => {
+      expect.assertions(1);
+
+      await expect(
+        global.server.app
+          .getModel('User')
+          .getUserByVerificationToken('fake one'),
+      ).rejects.toStrictEqual(new Error('User not exists'));
     });
 
     it('should  work for VALID token', async () => {
@@ -65,15 +117,13 @@ describe('user model', () => {
 
   describe('getUserByPasswordRecoveryToken', () => {
     it('should NOT work for non valid token', async () => {
-      expect.assertions(2);
+      expect.assertions(1);
 
-      const user = await global.server.app
-        .getModel('User')
-        .getUserByPasswordRecoveryToken('fake one')
-        .catch((e) => {
-          expect(e).toBeDefined();
-        });
-      expect(user).toBeUndefined();
+      await expect(
+        global.server.app
+          .getModel('User')
+          .getUserByPasswordRecoveryToken('fake one'),
+      ).rejects.toStrictEqual(new Error('User not exists'));
     });
 
     it('should  work for VALID token', async () => {

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;