@adaptivestone/framework 3.0.22 → 3.1.0

package/CHANGELOG.md

@@ -1,7 +1,13 @@
-### 3.1.0 // NEXT
+### 3.1.0
 
 [NEW] new comand to generate open API documentation (wip)
 [NEW] coverage report
+[UPDATE] updated deps
+
+### 3.0.23
+
+[UPDATE] updated deps
+[FIX] fix custom errors
 
 ### 3.0.22
 

package/commands/GetOpenApiJson.js

@@ -1,17 +1,51 @@
+const fs = require('fs').promises;
+
 const AbstractCommand = require('../modules/AbstractCommand');
 
+/**
+ * Command for generate documentation json file openApi
+ */
 class GetOpenApiJson extends AbstractCommand {
   async run() {
     const { myDomain } = this.app.getConfig('http');
+    let jsonFile = process.env.npm_package_json;
+    if (!jsonFile) {
+      jsonFile = `${process.env.PWD}/package.json`;
+    }
+
+    try {
+      // eslint-disable-next-line import/no-dynamic-require, global-require
+      jsonFile = require(jsonFile);
+    } catch (e) {
+      this.logger.error(
+        'No npm package detected. Please start this command via NPM as it depends on package.json',
+      );
+    }
+
+    if (!jsonFile) {
+      jsonFile = {
+        name: 'UNDETECTD PROJECT',
+        description: 'UNDETECTD PROJECT DECCRIPTION',
+        version: '0.0.0-undetrcted',
+        author: {
+          email: 'none@example.com',
+        },
+      };
+    }
+
+    if (!jsonFile.author) {
+      jsonFile.author = 'none@example.com';
+    }
+
     const openApi = {
       openapi: '3.0.0',
       info: {
-        title: 'Some title',
-        description: 'This is a simple API',
+        title: jsonFile.name,
+        description: jsonFile.description,
         contact: {
-          email: 'you@your-company.com',
+          email: jsonFile.author.email,
         },
-        version: '1.0.0',
+        version: jsonFile.version,
       },
       servers: [
         {
@@ -215,7 +249,12 @@ class GetOpenApiJson extends AbstractCommand {
     }
 
     const result = JSON.stringify(openApi);
-    console.log(result);
+
+    if (this.args.output) {
+      await fs.writeFile(this.args.output, result);
+      this.logger.info(`Output to: ${this.args.output}`);
+    }
+
     return result;
   }
 }

package/controllers/Auth.test.js

@@ -31,6 +31,26 @@ describe('auth', () => {
       expect(status).toBe(201);
     });
 
+    it('can  not create user with the same nickname', async () => {
+      expect.assertions(1);
+      await request(global.server.app.httpServer.express)
+        .post('/auth/register')
+        .send({
+          email: userEmail,
+          password: userPassword,
+          nickName: 'test',
+        });
+
+      const { status } = await request(global.server.app.httpServer.express)
+        .post('/auth/register')
+        .send({
+          email: userEmail2,
+          password: '123',
+          nickName: 'test',
+        });
+      expect(status).toBe(400);
+    });
+
     it('can NOT create SAME user', async () => {
       expect.assertions(1);
       const { status } = await request(global.server.app.httpServer.express)
@@ -90,6 +110,136 @@ describe('auth', () => {
   });
 
   describe('isAuthWithVefificationFlow auth option', () => {
+    it('can verify user', async () => {
+      expect.assertions(2);
+      const user = await global.server.app.getModel('User').create({
+        email: 'Test@gmail.com',
+        password: 'userPassword',
+        name: {
+          nick: 'nickname',
+        },
+      });
+
+      user.verificationTokens.push({
+        token: 'testToken',
+      });
+
+      await user.save();
+
+      const { status } = await request(
+        global.server.app.httpServer.express,
+      ).post(`/auth/verify?verification_token=testToken`);
+
+      const { isVerified } = await global.server.app.getModel('User').findOne({
+        email: 'Test@gmail.com',
+      });
+
+      expect(status).toBe(200);
+      expect(isVerified).toBeTruthy();
+    });
+
+    it('can not verify user with wrong token', async () => {
+      expect.assertions(2);
+      const user = await global.server.app.getModel('User').create({
+        email: 'Test423@gmail.com',
+        password: 'userPassword',
+        name: {
+          nick: 'nicknameee',
+        },
+      });
+
+      user.verificationTokens.push({
+        token: 'testToken',
+      });
+
+      await user.save();
+
+      const { status } = await request(
+        global.server.app.httpServer.express,
+      ).post(`/auth/verify?verification_token=testToken123wrong`);
+
+      const { isVerified } = await global.server.app.getModel('User').findOne({
+        email: 'Test423@gmail.com',
+      });
+
+      expect(status).toBe(400);
+      expect(isVerified).toBeFalsy();
+    });
+
+    it('can NOT send recovery to not exist email', async () => {
+      expect.assertions(1);
+      const { status } = await request(global.server.app.httpServer.express)
+        .post('/auth/send-recovery-email')
+        .send({
+          email: 'notExists@gmail.com',
+        });
+      expect(status).toBe(400);
+    });
+
+    it('can send recovery to exist email', async () => {
+      expect.assertions(1);
+      const { status } = await request(global.server.app.httpServer.express)
+        .post('/auth/send-recovery-email')
+        .send({
+          email: userEmail,
+        });
+      expect(status).toBe(200);
+    });
+
+    it('can recover password', async () => {
+      expect.assertions(1);
+
+      const user = await global.server.app.getModel('User').create({
+        email: 'Test1@gmail.com',
+        password: 'userPassword',
+        name: {
+          nick: 'nickname1',
+        },
+      });
+
+      user.passwordRecoveryTokens.push({
+        token: 'superPassword',
+      });
+
+      await user.save();
+
+      const { status } = await request(global.server.app.httpServer.express)
+        .post('/auth/recover-password')
+        .send({
+          password: 'newPass',
+          passwordRecoveryToken: 'superPassword',
+        });
+
+      expect(status).toBe(200);
+    });
+
+    it('can not recover password with wrong token', async () => {
+      expect.assertions(1);
+
+      const user = await global.server.app.getModel('User').create({
+        email: 'Test2@gmail.com',
+        password: 'userPassword',
+        name: {
+          nick: 'nickname2',
+        },
+      });
+
+      user.passwordRecoveryTokens.push({
+        token: 'superPassword',
+      });
+
+      await user.save();
+
+      const { status } = await request(global.server.app.httpServer.express)
+        .post('/auth/recover-password')
+        .send({
+          password: 'newPass',
+          passwordRecoveryToken: '13123',
+        });
+
+      expect(status).toBe(400);
+    });
+
     it('can login with normal creds and  NOT verifyed email is option isAuthWithVefificationFlow is set', async () => {
       expect.assertions(4);
 
@@ -129,6 +279,28 @@ describe('auth', () => {
     });
   });
 
+  it('can user send verification', async () => {
+    expect.assertions(1);
+
+    const { status } = await request(global.server.app.httpServer.express)
+      .post('/auth/send-verification')
+      .send({
+        email: userEmail2,
+      });
+    expect(status).toBe(200);
+  });
+
+  it('can not user send verification to wrong email', async () => {
+    expect.assertions(1);
+
+    const { status } = await request(global.server.app.httpServer.express)
+      .post('/auth/send-verification')
+      .send({
+        email: 'wrong@gmail.com',
+      });
+    expect(status).toBe(400);
+  });
+
   describe('rate limiter', () => {
     it('we  should receive 429 on rate limit exceeded', async () => {
       expect.assertions(1);

package/modules/AbstractController.js

@@ -221,7 +221,7 @@ class AbstractController extends Base {
                 );
 
                 const errorAnswer = {};
-                if (!e.inner.length) {
+                if (!e.inner || !e.inner.length) {
                   errorAnswer[e.path] = errors;
                 } else {
                   e.inner.forEach((err) => {

package/modules/Modules.test.js

@@ -0,0 +1,17 @@
+const SomeController = require('../controllers/test/SomeController');
+const AbstractController = require('./AbstractController');
+
+describe('abstract controller methods', () => {
+  it('can get routes', async () => {
+    expect.assertions(2);
+
+    const controller = new AbstractController(global.server.app);
+    const childController = new SomeController(global.server.app);
+
+    const { routes } = controller;
+    const { routes: childRoutes } = childController;
+
+    expect(routes).toStrictEqual({});
+    expect(childRoutes).toBeDefined();
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "3.0.22",
+  "version": "3.1.0",
   "description": "Adaptive stone node js framework",
   "main": "src/index.js",
   "engines": {
@@ -40,9 +40,9 @@
     "dotenv": "^16.0.0",
     "email-templates": "^10.0.0",
     "express": "^4.17.1",
-    "i18next": "^21.2.4",
-    "i18next-chained-backend": "^3.0.2",
-    "i18next-fs-backend": "^1.1.1",
+    "i18next": "^22.0.4",
+    "i18next-chained-backend": "^4.0.0",
+    "i18next-fs-backend": "^2.0.0",
     "i18next-http-middleware": "^3.1.4",
     "minimist": "^1.2.5",
     "mongoose": "^6.0.0",

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

@@ -0,0 +1,42 @@
+const RateLimiter = require('./RateLimiter');
+
+describe('middlewares methods', () => {
+  it('can create redis rateLimiter', async () => {
+    expect.assertions(1);
+
+    const redisRateLimiter = new RateLimiter(global.server.app, {
+      driver: 'redis',
+    });
+
+    expect(redisRateLimiter.limiter).toBeDefined();
+  });
+
+  it('can not create rateLimiter with unknown driver', async () => {
+    expect.assertions(1);
+
+    const rateLimiter = new RateLimiter(global.server.app, {
+      driver: 'unknown',
+    });
+
+    expect(rateLimiter.limiter).toBeNull();
+  });
+
+  it('generateConsumeKey works correctly', async () => {
+    expect.assertions(1);
+
+    const redisRateLimiter = new RateLimiter(global.server.app, {
+      driver: 'redis',
+    });
+
+    const res = await redisRateLimiter.gerenateConsumeKey({
+      ip: '192.168.0.0',
+      appInfo: {
+        user: {
+          id: 'someId',
+        },
+      },
+    });
+
+    expect(res).toBe('192.168.0.0__someId');
+  });
+});