@adaptivestone/framework 4.5.0 → 4.6.0

package/coverage/sorter.js

@@ -0,0 +1,196 @@
+/* eslint-disable */
+var addSorting = (function() {
+    'use strict';
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            if (
+                row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase())
+            ) {
+                row.style.display = '';
+            } else {
+                row.style.display = 'none';
+            }
+        }
+    }
+
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function(a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function(a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function() {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function() {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);

package/models/Sequence.test.js

@@ -1,3 +1,5 @@
+import { describe, it, expect } from 'vitest';
+
 describe('sequence model', () => {
   it('should produce sequence', async () => {
     expect.assertions(1);

package/models/User.test.js

@@ -1,3 +1,5 @@
+import { describe, it, expect } from 'vitest';
+
 const userEmail = 'testing@test.com';
 const userPassword = 'SuperNiceSecret123$';
 

package/modules/Modules.test.js

@@ -1,5 +1,6 @@
-const SomeController = require('../controllers/test/SomeController');
-const AbstractController = require('./AbstractController');
+import { describe, it, expect } from 'vitest';
+import SomeController from '../controllers/test/SomeController';
+import AbstractController from './AbstractController';
 
 describe('abstract controller methods', () => {
   it('can get routes', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptivestone/framework",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "Adaptive stone node js framework",
   "main": "index.js",
   "engines": {
@@ -14,7 +14,7 @@
   "scripts": {
     "dev": "nodemon ./index.js",
     "prod": "nodemon ./cluster.js",
-    "test": "jest --coverage=true",
+    "test": "vitest  run --coverage",
     "prettier": "prettier --check '**/*.(js|jsx|ts|tsx|json|css|scss|md)'",
     "lint": "eslint '**/*.js'",
     "lint:fix": "eslint '**/*.js' --fix",
@@ -25,18 +25,6 @@
     "benchmark2": "h2load -n 10000 -c 50  https://localhost:3300/",
     "redis:docker": "docker run --rm  -p 6379:6379 redis"
   },
-  "jest": {
-    "setupFilesAfterEnv": [
-      "./tests/setup.js"
-    ],
-    "testEnvironment": "node",
-    "verbose": true,
-    "collectCoverage": true,
-    "coverageReporters": [
-      "text",
-      "text-summary"
-    ]
-  },
   "author": "Andrey Logunov",
   "license": "MIT",
   "dependencies": {
@@ -63,17 +51,17 @@
     "yup": "^1.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.22.15",
+    "@vitest/coverage-v8": "^0.34.3",
     "eslint": "^8.0.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-jest": "^27.0.0",
+    "eslint-plugin-vitest": "^0.3.1",
     "husky": "^8.0.0",
-    "jest": "^29.0.0",
     "lint-staged": "^14.0.0",
     "mongodb-memory-server": "^8.0.2",
     "nodemon": "^3.0.1",
-    "prettier": "^3.0.0"
+    "prettier": "^3.0.0",
+    "vitest": "^0.34.3"
   },
   "lint-staged": {
     "**/*.{js,jsx,ts,tsx,json,css,scss,md}": [

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

@@ -1,4 +1,5 @@
-const I18n = require('./I18n');
+import { beforeAll, describe, it, expect } from 'vitest';
+import I18n from './I18n';
 
 describe('i18n middleware methods', () => {
   let middleware;
@@ -45,13 +46,16 @@ describe('i18n middleware methods', () => {
 
   it('middleware that works', async () => {
     expect.assertions(4);
-    const nextFunction = jest.fn(() => {});
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
     const req = {
       get: () => 'en',
       appInfo: {},
     };
     await middleware.middleware(req, {}, nextFunction);
-    expect(nextFunction).toHaveBeenCalledWith();
+    expect(isCalled).toBe(true);
     expect(req.appInfo.i18n).toBeDefined();
     expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
     expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test
@@ -62,13 +66,16 @@ describe('i18n middleware methods', () => {
     global.server.app.updateConfig('i18n', { enabled: false });
     middleware = new I18n(global.server.app);
 
-    const nextFunction = jest.fn(() => {});
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
     const req = {
       get: () => 'en',
       appInfo: {},
     };
     await middleware.middleware(req, {}, nextFunction);
-    expect(nextFunction).toHaveBeenCalledWith();
+    expect(isCalled).toBe(true);
     expect(req.appInfo.i18n).toBeDefined();
     expect(req.appInfo.i18n.t('aaaaa')).toBe('aaaaa');
     expect(req.i18n.t('aaaaa')).toBe('aaaaa'); // proxy test

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

@@ -1,4 +1,5 @@
-const PrepareAppInfo = require('./PrepareAppInfo');
+import { describe, it, expect } from 'vitest';
+import PrepareAppInfo from './PrepareAppInfo';
 
 describe('prepareAppInfo methods', () => {
   it('have description fields', async () => {
@@ -10,10 +11,13 @@ describe('prepareAppInfo methods', () => {
   it('middleware that works', async () => {
     expect.assertions(3);
     const middleware = new PrepareAppInfo(global.server.app);
-    const nextFunction = jest.fn(() => {});
+    let isCalled = false;
+    const nextFunction = () => {
+      isCalled = true;
+    };
     const req = {};
     await middleware.middleware(req, {}, nextFunction);
-    expect(nextFunction).toHaveBeenCalledWith();
+    expect(isCalled).toBe(true);
     expect(req.appInfo).toBeDefined();
     req.appInfo.test = 5;
     await middleware.middleware(req, {}, nextFunction);

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

@@ -1,14 +1,19 @@
-const { setTimeout } = require('node:timers/promises');
-const RateLimiter = require('./RateLimiter');
+import { setTimeout } from 'node:timers/promises';
+import crypto from 'node:crypto';
+import { beforeAll, afterAll, describe, it, expect } from 'vitest';
+
+import RateLimiter from './RateLimiter';
 
 let mongoRateLimiter;
 
 describe('rate limiter methods', () => {
-  beforeAll(() => {
+  beforeAll(async () => {
+    await setTimeout(20);
+
     mongoRateLimiter = new RateLimiter(global.server.app, {
       driver: 'mongo',
       limiterOptions: {
-        keyPrefix: `mongo_${Date.now()}`,
+        keyPrefix: `mongo_${Date.now()}_${crypto.randomUUID()}}`,
       },
     });
   });
@@ -89,7 +94,6 @@ describe('rate limiter methods', () => {
     const rateLimiter = new RateLimiter(global.server.app, {
       driver: 'unknown',
     });
-    const nextFunction = jest.fn(() => {});
     const req = {
       appInfo: {},
     };
@@ -106,7 +110,7 @@ describe('rate limiter methods', () => {
           isSend = true;
         },
       },
-      nextFunction,
+      () => {},
     );
     expect(status).toBe(500);
     expect(isSend).toBe(true);

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

@@ -1,7 +1,10 @@
-const { createServer } = require('node:http');
-const formidable = require('formidable');
+import { createServer } from 'node:http';
+import { describe, it, expect } from 'vitest';
+
+import RequestParser from './RequestParser';
 
-const RequestParser = require('./RequestParser');
+// TODO change on ESM
+const formidable = require('formidable');
 
 describe('reqest parser limiter methods', () => {
   it('have description fields', async () => {
@@ -24,7 +27,7 @@ describe('reqest parser limiter methods', () => {
           expect(req.body.multipleFiles).toBeDefined();
           expect(
             req.body.multipleFiles[0] instanceof formidable.PersistentFile,
-          ).toBe(true);
+          ).toBeTruthy();
 
           res.writeHead(200);
           res.end('ok');

package/services/validate/ValidateService.test.js

@@ -1,3 +1,5 @@
+import { describe, it, expect } from 'vitest';
+
 const yup = require('yup');
 const ValidateService = require('./ValidateService');
 const YupValidator = require('./drivers/YupValidator');

package/tests/setup.js

@@ -1,5 +1,5 @@
+/* eslint-disable no-undef */
 const path = require('node:path');
-/* eslint-disable jest/require-top-level-describe */
 const { MongoMemoryReplSet } = require('mongodb-memory-server');
 const mongoose = require('mongoose');
 

package/tests/setupVitest.js

@@ -0,0 +1,119 @@
+import path from 'node:path';
+import { beforeAll, beforeEach, afterEach, afterAll } from 'vitest';
+
+const { MongoMemoryReplSet } = require('mongodb-memory-server');
+
+const mongoose = require('mongoose');
+
+let mongoMemoryServerInstance;
+
+const redis = require('redis');
+const Server = require('../server');
+
+const clearRedisNamespace = require('../helpers/redis/clearNamespace');
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+beforeAll(async () => {
+  mongoMemoryServerInstance = await MongoMemoryReplSet.create({
+    // binary: { version: '4.4.6' },
+    replSet: { count: 1, storageEngine: 'wiredTiger' },
+  });
+  await mongoMemoryServerInstance.waitUntilRunning();
+  process.env.LOGGER_CONSOLE_LEVEL = 'error';
+  const connectionStringMongo = await mongoMemoryServerInstance.getUri();
+  // console.info('MONGO_URI: ', connectionStringMongo);
+  global.server = new Server({
+    folders: {
+      config: process.env.TEST_FOLDER_CONFIG || path.resolve('./config'),
+      controllers:
+        process.env.TEST_FOLDER_CONTROLLERS || path.resolve('./controllers'),
+      views: process.env.TEST_FOLDER_VIEWS || path.resolve('./views'),
+      public: process.env.TEST_FOLDER_PUBLIC || path.resolve('./public'),
+      models: process.env.TEST_FOLDER_MODELS || path.resolve('./models'),
+      emails:
+        process.env.TEST_FOLDER_EMAIL ||
+        process.env.TEST_FOLDER_EMAILS ||
+        path.resolve('./services/messaging/email/templates'),
+      locales: process.env.TEST_FOLDER_LOCALES || path.resolve('./locales'),
+      commands: process.env.TEST_FOLDER_COMMANDS || path.resolve('./commands'),
+      migrations:
+        process.env.TEST_FOLDER_MIGRATIONS || path.resolve('./migrations'),
+    },
+  });
+  global.server.updateConfig('mongo', {
+    connectionString: connectionStringMongo,
+  });
+  global.server.updateConfig('http', { port: 0 }); // allow to use random
+  global.server.updateConfig('mail', { transport: 'stub' });
+  if (!global.testSetup) {
+    global.testSetup = {};
+  }
+  global.server.testingGetUrl = (urlPart) =>
+    `http://127.0.0.1:${global.server.getConfig('http').port}${urlPart}`;
+  if (!global.testSetup.disableUserCreate) {
+    const User = global.server.app.getModel('User');
+    global.user = await User.create({
+      email: 'test@test.com',
+      password: 'testPassword',
+      isVerified: true,
+      name: {
+        nick: 'testUserNickName',
+      },
+    }).catch((e) => {
+      // eslint-disable-next-line no-console
+      console.error(e);
+      // eslint-disable-next-line no-console
+      console.info(
+        'That error can happens in case you have custom user model. Please use global.testSetup.disableUserCreate flag to skip user creating',
+      );
+    });
+    global.authToken = await global.user.generateToken();
+  }
+  if (typeof global.testSetup.beforeAll === 'function') {
+    await global.testSetup.beforeAll();
+  }
+  await global.server.startServer();
+});
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+beforeEach(() => {
+  if (global.server) {
+    const key = `test-${Math.random().toString(36).substring(7)}`;
+    global.server.app.updateConfig('redis', {
+      namespace: key,
+    });
+  }
+});
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+afterEach(async () => {
+  if (global.server) {
+    const { url, namespace } = global.server.getConfig('redis');
+    const redisClient = redis.createClient({ url });
+
+    try {
+      await redisClient.connect();
+      await clearRedisNamespace(redisClient, namespace);
+      await redisClient.disconnect();
+    } catch (err) {
+      // that ok. No redis connection
+    }
+  }
+});
+
+// eslint-disable-next-line vitest/no-hooks, vitest/require-top-level-describe
+afterAll(async () => {
+  if (global.server) {
+    global.server.app.httpServer.shutdown();
+    global.server.app.events.emit('shutdown');
+  }
+  // setTimeout(async () => {
+  if (typeof global.testSetup.afterAll === 'function') {
+    await global.testSetup.afterAll();
+  }
+
+  await mongoose.disconnect();
+  await mongoMemoryServerInstance.stop();
+
+  // }, 2000);
+});

package/vitest.config.js

@@ -0,0 +1,9 @@
+// eslint-disable-next-line import/no-unresolved
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    setupFiles: './tests/setupVitest.js',
+    testTimeout: 10000,
+  },
+});

package/babel.config.js

@@ -1,3 +0,0 @@
-module.exports = {
-  presets: [['@babel/preset-env', { targets: { node: 'current' } }]],
-};