@adaptivestone/framework 3.0.23 → 3.1.1

package/CHANGELOG.md

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

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/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.23",
+  "version": "3.1.1",
   "description": "Adaptive stone node js framework",
   "main": "src/index.js",
   "engines": {

package/services/cache/Cache.js

@@ -35,21 +35,33 @@ class Cache extends Base {
     const key = `${this.redisNamespace}-${keyValue}`;
     // 5 mins default
     let resolve = null;
+    let reject = null;
     if (this.promiseMapping.has(key)) {
       return this.promiseMapping.get(key);
     }
 
     this.promiseMapping.set(
       key,
-      new Promise((res) => {
+      new Promise((res, rej) => {
         resolve = res;
+        reject = rej;
       }),
     );
 
     let result = await this.redisClient.get(key);
     if (!result) {
       this.logger.verbose(`getSetValueFromCache not found for key ${key}`);
-      result = await onNotFound();
+      try {
+        result = await onNotFound();
+      } catch (e) {
+        this.logger.error(
+          `Cache onNotFound for key '${key}' error: ${e.message}`,
+        );
+        this.promiseMapping.delete(key);
+        reject(e);
+        return Promise.reject(e);
+      }
+
       this.redisClient.setEx(key, storeTime, JSON.stringify(result));
     } else {
       this.logger.verbose(

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');
+  });
+});