@adaptivestone/framework 5.0.0-alpha.10 → 5.0.0-alpha.11

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 5.0.0-alpha.11
+
+[UPDATE] update deps
+
 ### 5.0.0-alpha.10
 
 [UPDATE] update deps

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "5.0.0-alpha.10",
+  "version": "5.0.0-alpha.11",
   "description": "Adaptive stone node js framework",
   "main": "index.js",
   "type": "module",
@@ -48,7 +48,7 @@
     "rate-limiter-flexible": "^5.0.0",
     "redis": "^4.3.1",
     "winston": "^3.3.3",
-    "winston-transport-sentry-node": "^2.0.0",
+    "winston-transport-sentry-node": "^3.0.0",
     "yup": "^1.0.0"
   },
   "devDependencies": {

package/.eslintrc.cjs

@@ -1,41 +0,0 @@
-module.exports = {
-  env: {
-    es2023: true,
-    node: true,
-  },
-  extends: ['airbnb-base', 'prettier'],
-  plugins: ['prettier'],
-  parserOptions: {
-    ecmaVersion: 2023,
-  },
-  rules: {
-    'no-restricted-syntax': [
-      'error',
-      {
-        selector: 'ForInStatement',
-        message:
-          'for..in loops iterate over the entire prototype chain, which is virtually never what you want. Use Object.{keys,values,entries}, and iterate over the resulting array.',
-      },
-      {
-        selector: 'LabeledStatement',
-        message:
-          'Labels are a form of GOTO; using them makes code confusing and hard to maintain and understand.',
-      },
-      {
-        selector: 'WithStatement',
-        message:
-          '`with` is disallowed in strict mode because it makes code impossible to predict and optimize.',
-      },
-    ],
-    'prettier/prettier': 'error',
-    'import/extensions': 'off', // it have a problem with dynamic imports
-    'import/prefer-default-export': 'off', // we want to have signgke default export too
-  },
-  overrides: [
-    {
-      files: ['**/*.test.js'],
-      extends: ['plugin:vitest/all', 'plugin:vitest/recommended'],
-      plugins: ['vitest'],
-    },
-  ],
-};

package/controllers/Auth.test.js

@@ -1,451 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-const userEmail = 'testing@test.com';
-const userPassword = 'SuperNiceSecret123$';
-
-const userEmail2 = 'testing2@test.com';
-
-describe('auth', () => {
-  describe('registration', () => {
-    it('code NOT able to create user with wrong email', async () => {
-      expect.assertions(1);
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/register'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: 'bad email',
-            password: userPassword,
-            nickName: 'test',
-          }),
-        },
-      ).catch(() => {});
-
-      expect(status).toBe(400);
-    });
-
-    it('can create user', async () => {
-      expect.assertions(1);
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/register'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail,
-            password: userPassword,
-            nickName: 'test',
-          }),
-        },
-      );
-      expect(status).toBe(201);
-    });
-
-    it('can  not create user with the same nickname', async () => {
-      expect.assertions(1);
-      await fetch(global.server.testingGetUrl('/auth/register'), {
-        method: 'POST',
-        headers: {
-          'Content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          email: userEmail,
-          password: userPassword,
-          nickName: 'test',
-        }),
-      });
-
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/register'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail2,
-            password: '123',
-            nickName: 'test',
-          }),
-        },
-      ).catch(() => {});
-
-      expect(status).toBe(400);
-    });
-
-    it('can NOT create SAME user', async () => {
-      expect.assertions(1);
-
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/register'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail,
-            password: userPassword,
-            nickName: 'test',
-          }),
-        },
-      );
-
-      expect(status).toBe(400);
-    });
-  });
-
-  describe('login', () => {
-    it('can NOT login with normal creds and not verified email', async () => {
-      expect.assertions(1);
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/login'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail,
-            password: userPassword,
-          }),
-        },
-      ).catch(() => {});
-
-      expect(status).toBe(400);
-    });
-
-    it('can NOT login with WRONG creds', async () => {
-      expect.assertions(1);
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/login'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: 'test@test.by',
-            password: 'noPassword$',
-          }),
-        },
-      ).catch(() => {});
-      expect(status).toBe(400);
-    });
-
-    it('can login with normal creds and verified email', async () => {
-      expect.assertions(2);
-
-      const user = await global.server.app
-        .getModel('User')
-        .findOne({ email: userEmail });
-      user.isVerified = true;
-      await user.save();
-
-      const response = await fetch(global.server.testingGetUrl('/auth/login'), {
-        method: 'POST',
-        headers: {
-          'Content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          email: userEmail,
-          password: userPassword,
-        }),
-      });
-
-      const responseBody = await response.json();
-
-      expect(response.status).toBe(200);
-      expect(responseBody.token).toBeDefined();
-    });
-  });
-
-  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 fetch(
-        `${global.server.testingGetUrl(
-          '/auth/verify',
-        )}?verification_token=testToken`,
-        {
-          method: 'POST',
-        },
-      );
-
-      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 fetch(
-        `${global.server.testingGetUrl(
-          '/auth/verify',
-        )}?verification_token=testToken123wrong`,
-        {
-          method: 'POST',
-        },
-      );
-
-      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 fetch(
-        global.server.testingGetUrl('/auth/send-recovery-email'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: 'notExists@gmail.com',
-          }),
-        },
-      );
-
-      expect(status).toBe(400);
-    });
-
-    it('can send recovery to exist email', async () => {
-      expect.assertions(1);
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/send-recovery-email'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            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 fetch(
-        global.server.testingGetUrl('/auth/recover-password'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            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 fetch(
-        global.server.testingGetUrl('/auth/recover-password'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            password: 'newPass',
-            passwordRecoveryToken: '13123',
-          }),
-        },
-      );
-
-      expect(status).toBe(400);
-    });
-
-    it('can login with normal creds and NOT verifyed email if option isAuthWithVefificationFlow is set', async () => {
-      expect.assertions(4);
-
-      const { status } = await fetch(
-        global.server.testingGetUrl('/auth/register'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail2,
-            password: userPassword,
-          }),
-        },
-      );
-
-      const { status: status2 } = await fetch(
-        global.server.testingGetUrl('/auth/login'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail2,
-            password: userPassword,
-          }),
-        },
-      );
-
-      global.server.app.updateConfig('auth', {
-        isAuthWithVefificationFlow: false,
-      });
-
-      const response3 = await fetch(
-        global.server.testingGetUrl('/auth/login'),
-        {
-          method: 'POST',
-          headers: {
-            'Content-type': 'application/json',
-          },
-          body: JSON.stringify({
-            email: userEmail2,
-            password: userPassword,
-          }),
-        },
-      );
-
-      const responseBody3 = await response3.json();
-
-      expect(status).toBe(201);
-      expect(status2).toBe(400);
-      expect(response3.status).toBe(200);
-      expect(responseBody3.token).toBeDefined();
-    });
-  });
-
-  it('can user send verification', async () => {
-    expect.assertions(1);
-
-    const { status } = await fetch(
-      global.server.testingGetUrl('/auth/send-verification'),
-      {
-        method: 'POST',
-        headers: {
-          'Content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          email: userEmail2,
-        }),
-      },
-    );
-
-    expect(status).toBe(200);
-  });
-
-  it('can not user send verification to wrong email', async () => {
-    expect.assertions(1);
-
-    const { status } = await fetch(
-      global.server.testingGetUrl('/auth/send-verification'),
-      {
-        method: 'POST',
-        headers: {
-          'Content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          email: 'wrong@gmail.com',
-        }),
-      },
-    );
-
-    expect(status).toBe(400);
-  });
-
-  describe('rate limiter', () => {
-    it('should receive 429 on rate limit exceeded', async () => {
-      expect.assertions(1);
-
-      const requests = Array.from({ length: 11 }, () =>
-        fetch(global.server.testingGetUrl('/auth/logout'), {
-          method: 'POST',
-        }),
-      );
-
-      const responses = await Promise.all(requests);
-      const statusCodes = responses.map((response) => response.status);
-
-      expect(statusCodes).toContain(429);
-    });
-  });
-});

package/controllers/Home.test.js

@@ -1,12 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('home', () => {
-  it('can open home have', async () => {
-    expect.assertions(1);
-    const { status } = await fetch(global.server.testingGetUrl('/')).catch(
-      () => {},
-    );
-
-    expect(status).toBe(200);
-  });
-});

package/models/Migration.test.js

@@ -1,20 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('migration model', () => {
-  it('migrationFile should be uniqe', async () => {
-    expect.assertions(1);
-    let errorCode;
-    const MigrationModel = global.server.app.getModel('Migration');
-    await MigrationModel.syncIndexes();
-    await MigrationModel.create({
-      migrationFile: 'a',
-    });
-    await MigrationModel.create({
-      migrationFile: 'a',
-    }).catch((e) => {
-      errorCode = e.code;
-    });
-
-    expect(errorCode).toBe(11000);
-  });
-});

package/models/Sequence.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-describe('sequence model', () => {
-  it('should produce sequence', async () => {
-    expect.assertions(1);
-    const SequenceModel = global.server.app.getModel('Sequence');
-
-    const number1 = await SequenceModel.getSequence('typeOne');
-
-    expect(number1).toBe(1);
-  });
-
-  it('should produce sequence different for different types', async () => {
-    expect.assertions(3);
-    const SequenceModel = global.server.app.getModel('Sequence');
-
-    const number1 = await SequenceModel.getSequence('typeOneAgain');
-    const number2 = await SequenceModel.getSequence('typeTwo');
-    const number3 = await SequenceModel.getSequence('typeThree');
-
-    expect(number1).toBe(1);
-    expect(number2).toBe(1);
-    expect(number3).toBe(1);
-  });
-
-  it('should works on async env', async () => {
-    expect.assertions(1);
-    const SequenceModel = global.server.app.getModel('Sequence');
-
-    const promises = [];
-    const upTo = 100;
-    for (let i = 0; i < upTo; i += 1) {
-      promises.push(SequenceModel.getSequence('asyncTypeOne'));
-    }
-
-    const data = await Promise.all(promises);
-    const summ = ((1 + upTo) / 2) * upTo; // Arithmetic progression
-
-    const summ2 = data.reduce((a, b) => a + b, 0);
-
-    expect(summ2).toBe(summ);
-  });
-});