DEV Community: Paulo

How to test Vuex with Nuxt

Paulo — Sun, 22 May 2022 15:09:18 +0000

Hello, in this article we will learn how to test Vuex. We are going to use the Nuxt.js framework to create the project, first what is Vuex, Vuex is a state management standard for Vue.js applications. It serves as a centralized store for all components in an application, with rules ensuring that state can only be mutated in a predictable way. Our project will be a simple project, it will be an application to increment and decrement a number, let's start.

Install Vue:

npm install -g @vue/cli
# OR
yarn global add @vue/cli

You can check you have the right version with this command:

vue --version

When creating the project you will have some project configuration options you can feel free to choose your configuration, but you must select Jest in Testing framework, I will show you the options chosen when creating this project:

Programing language: Javascript
Package manager: npm 
UI framework: none
Nuxt.js modules: axios
Linting tools: Eslint, Prettier e Lint staged files
Testing framework: Jest
Rendering mode: Universal
Deployment target: Serve
Deployment tools: jsconfig
Continuous integration: None
Version control system: Git

command to create project:

npm init nuxt-app <project-name>
# OR
npx create-nuxt-app <project-name>

Okay, after creating the project we are going to install a dependency that will help us in the development of the tests

npm install @types/jest --save-dev

After all the installations we go to the package.json file to add one more script.

"test:watch": "jest --watchAll",
"test:coverage": "jest --coverage",

before running the script, go to the jest.config.js file to make some changes, add the false value to collectCoverage, as this will not generate coverage for each change made to the project and the next change is to add to collectCoverageFrom the store directory that is /store/*/.js this will make jest run in the store folder.

Now we can run this command:

npm run test:watch

Ready now the project is running the tests, when finishing these settings let's go to practice let's create a file in the store folder with the following name counter in nuxt.js already perform the export of the file with the name you put in the file the nuxt .js already does this automatically. In our article we just need the state which is an object that contains all the state of your application and serves as the "single source of truth" and mutations which is the only way to actually change state in a Vuex store.

As we are developing using the TDD method (Test Driven Development) in which we write the test first that the functionality is now going to create another file that will be the test file the file name will be counter.unit.spec.js it can be created in the same folder where the counter is or in a test folder.

We are going to carry out the necessary imports to carry out the tests, we must import createLocalVue, vuex and its store. Stays like this:

import { createLocalVue } from '@vue/test-utils'
import Vuex from 'vuex'
import { mutations, state } from '@/store/counter.js'

now let's create the tests first let's group the tests inside a describe and describe also describes what those tests are. Inside the describe we will create a function that will be called and return the store and with this store we will be able to access the state, mutations, actions and getters. the describe with the function is like this:

describe('Counter store', () => {
  const createStore = () => {
    const localVue = createLocalVue()
    localVue.use(Vuex)

    const store = new Vuex.Store({ state, mutations })

    return { store }
  }
})

The first test we are going to create will be the test to see the state of the value of the counter where its initial value is zero. The first test looks like this:

describe('Counter store', () => {
  const createStore = () => {
    const localVue = createLocalVue()
    localVue.use(Vuex)

    const store = new Vuex.Store({ state, mutations })

    return { store }
  }

  it('State => counter should start with the value zero', () => {
    const { store } = createStore()
    expect(store.state.counter).toEqual(0)
  })
})

now let's test the mutations when the increment method is called the value of the counter must increase one more example the value of the counter is 0 when the increment is called the value of the counter must be 1. The code looks like this:

describe('Counter store', () => {
  const createStore = () => {
    const localVue = createLocalVue()
    localVue.use(Vuex)

    const store = new Vuex.Store({ state, mutations })

    return { store }
  }

  it('State => counter should start with the value zero', () => {
    const { store } = createStore()
    expect(store.state.counter).toEqual(0)
  });
  it('Mutation => should increment one more when increment is called ', () => {
    const { store } = createStore()
    store.commit('increment')
    expect(store.state.counter).toEqual(1)
    store.commit('increment')
    expect(store.state.counter).toEqual(2)
  })

})

now let's test the decrement method when it is called the counter value must decrease by one more. example the value of the counter is 0 when the increment is called the value of the counter must be -1. The code looks like this:

describe('Counter store', () => {
  const createStore = () => {
    const localVue = createLocalVue()
    localVue.use(Vuex)

    const store = new Vuex.Store({ state, mutations })

    return { store }
  }

  it('State => counter should start with the value zero', () => {
    const { store } = createStore()
    expect(store.state.counter).toEqual(0)
  });
  it('Mutation => should increment one more when increment is called ', () => {
    const { store } = createStore()
    store.commit('increment')
    expect(store.state.counter).toEqual(1)
    store.commit('increment')
    expect(store.state.counter).toEqual(2)
  });
it('Mutation => should decrement one more when decrement is called ', async () => {
    const { store } = createStore()
    await store.commit('decrement')
    expect(store.state.counter).toEqual(-1)
    await store.commit('decrement')
    expect(store.state.counter).toEqual(-2)
  })

})

The last test will be to reset the value of the counter, the name of this method will be reset and when it is called, it must reset the value of the counter. Your test looked like this:

describe('Counter store', () => {
  const createStore = () => {
    const localVue = createLocalVue()
    localVue.use(Vuex)

    const store = new Vuex.Store({ state, mutations })

    return { store }
  }

  it('State => counter should start with the value zero', () => {
    const { store } = createStore()
    expect(store.state.counter).toEqual(0)
  });
  it('Mutation => should increment one more when increment is called ', () => {
    const { store } = createStore()
    store.commit('increment')
    expect(store.state.counter).toEqual(1)
    store.commit('increment')
    expect(store.state.counter).toEqual(2)
  });
it('Mutation => should decrement one more when decrement is called ', () => {
    const { store } = createStore()
    store.commit('decrement')
    expect(store.state.counter).toEqual(-1)
    store.commit('decrement')
    expect(store.state.counter).toEqual(-2)
  });
it('Mutation => should reset counter when reset is called ', () => {
    const { store } = createStore()
    store.commit('increment')
    store.commit('reset')
    expect(store.state.counter).toEqual(0)
    store.commit('decrement')
    store.commit('reset')
    expect(store.state.counter).toEqual(0)
  })

})

the counter file code in the store folder looks like this:

export const state = () => ({
  counter: 0,
})

export const mutations = {
  increment: (state) => {
    state.counter++
  },
  decrement: (state) => {
    state.counter--
  },
  reset: (state) => {
    state.counter = 0
  },
}

export const actions = {}

export const getters = {}

Thanks for reading the article and any questions about testing with vuex visit this site:
https://v1.test-utils.vuejs.org/guides/using-with-vuex.html
https://lmiller1990.github.io/vue-testing-handbook/vuex-in-components.html#using-createlocalvue-to-test-store-state

Depuração avançada de Javascript com console.table()

Paulo — Wed, 17 Mar 2021 12:04:47 +0000

O console.table() permite exibir dados no console em um formato tabular agravável. É muito útil para visualizar matrizes ou objetos complexos. Ele pode exibir dados tabulares para a matrizes ou objetos:

let person = [
 { firstName: 'Paulo', lastName: 'Sobrinho' },
 { firstName: 'Matheus', lastName: 'Gomes' },
 { firstName: 'Beatriz', lastName: 'Ribeiro' }
];

console.log(person);

Com o console.log() fornecerá a seguinte representação de seus dados:

Registro de dados de matriz com console.table()

Em vez de chamar console.log(), usaremos console.table() agora:

console.table(person);

Com o console.table() fornecerá a seguinte representação de seus dados:

Filtrando as propriedades do objeto exibido

Se quiser restringir as colunas a certas propriedades, você pode passar uma matriz de suas chaves como um segundo parâmetro para a console.table() chamada:

console.table(person, ['firstName', 'lastName']);

Para uma única propriedade, uma string simples é suficiente:

console.table(person, 'firstName');

Resultado:

Obrigado!

Iniciando projeto Nodejs com ORM Sequelize

Paulo — Mon, 15 Mar 2021 23:21:27 +0000

Introdução

Nesse artigo vou apresentar como inicia um projeto em Node.js com Sequelize, Express e Banco de Dados Postgres.

Node.js

O Node.js pode ser definido como um ambiente de execução Javascript server-side. Isso significa que com o Node.js é possível criar aplicações Javascript para rodar como uma aplicação standalone em uma máquina. Apesar de recente, o Node.js já é utilizado por grandes empresas no mercado de tecnologia, com Netfilx, Uber e LinkedIn.

Sequelize

O Sequelize é um ORM baseado em Promise para Node.js, que suporta os dialetos PostgreSQL,MariaDB, MySQL, MSSQL e SQLite. E recursos a transação, relacionamentos, replicação de leitura e muito mais.
Ele possui um mecanismo de migração muito poderoso que pode transformar um esquema existente de banco de dados em uma nova versão, e também fornece mecanismos de sincronização de DB que podem criar estrutura de banco de dados especificando a estrutura do modelo.

Iniciando o projeto

Vamos começar a criar o projeto em Node.js, primeiro você tem que ter algum banco de dados instalado na sua máquina ou usar algum banco on-line, como Heroku ou elepahnt.sql para usar com o Sequelize. Depois de ter instalado, você cria a pasta com o nome que desejar não é relevante, em seguida, entre na pasta que você criou e execute esse comando(via terminal):

npm init

Com esse comando, você dará procedimento à inicialização do seu projeto. Esse comando funciona como uma ferramenta para criar o arquivo package. json de um projeto. Dentro dela vamos fazer instalações de algumas dependências.

Instalação

Instalando as dependências do projeto.

npm install sequelize express pg bcrypt
npm install -D sequelize-cli

Dependências	README
express	O Express. js é um Framework rápido e um dos mais utilizados em conjunto com o Node.js obs:(use express a partir da versão 4.16.0)
pg	Cliente PostgreSQL sem bloqueio para Node.js
bcrypt	bcrypt é um método de criptografia do tipo hash para senhas baseado no Blowfish.

Com as dependências instaladas, vamos criar uma pasta chamada src vamos usar o padrão MVC. Dentro da pasta src crie um arquivo chamado index.js, nele ficará as configurações do projeto é o arquivo principal do projeto. Em seguida, crie as seguintes pastas:

router ficará os arquivos de rotas da api;
controller ficará os arquivos da regra de negócio;
db ficará as pastas migrations e seeders

//exportando as dependências instaladas e configurando as 
const express = require("express");
const router = require('./router');

const app = express();

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use("/", router);

module.exports = app;

Na pasta router crie um arquivo index.js

//nesse arquivos terá a configuração das rotas do projeto.
const { Router } = require("express");
const router = Router();

router.get('/', async (req, res) => {
    res.send('api running!'); 
});

module.exports = router;

Na raiz do projeto crie um arquivo chamado de app.js. Nesse arquivo estou iniciando o projeto na porta 3000, a constante app esta recebendo a importação dos arquivos src/index.js, quando queremos importar um arquivo index.js não precisamos escreve-lo no diretório do require('./src/index.js'), pois, por padrão ele já vai buscar esse arquivo index.js, então não precisamos colocar o nome index.js.

const app = require('./src');
app.listen(3000, () => console.info('app runnning on port 3000'));

No terminal execute esse comando:

node app.js

A aplicação será iniciada. No navegador ou em uma ferramenta que dá suporte à documentação das requisições feitas pela API. Acesse o endereço http://localhost:3000 caso esteja tudo correto, irá exibir essa mensagem na tela api running!

Configurando o Sequelize

Primeiro vamos iniciar o Sequelize com esse comando:

npx sequelize  init

Com esse comando, o Sequelize cria alguns arquivos no projeto, como a pasta config, migrations, models e seeders. O projeto ficará assim:

//config
//migrations
//models
//node_modules
//seeders
//src
////controller
////db
////router
////index.js
//app.js
//package.json

Altere para:

//node_modules
//src
////config
////controller
////db
//////migrations
//////seeders
////models
////router
////index.js
//app.js
//package.json

Agora vamos fazer algumas alterações, primeiro vamos à pasta config, nela contém um arquivo chamado de config.json renomei para config.js, e crie outro arquivo chamado de database.js.
à pasta config ficará assim:

//config
////config.js
////database.js

O arquivo config.js altere seu conteúdo para:

module.exports = {
  username: "",
  password: "",
  database: "",
  host: "",
  port: ,
  dialect: "postgres",
  define: {
    timestamps:true
  }
};

informe as credências para a conexão do banco de dados.

O arquivo database.js adicione esse código:

const { Sequelize } = require("sequelize");
const config = require('./config');

const sequelize = new Sequelize(
    config.database,
    config.username,
    config.password,
    {
      dialect: "postgres",
      port: config.port,
    },
    config.define
  );

module.exports = sequelize;

Vamos configurar os models da aplicação, os models são a representação das tabelas do banco de dados em forma de classe, pois, assim podemos manipulá-las mais facilmente através do código. No arquivo models/index.js que é responsável por importar os outros models da aplicação. Altere o models/indes.js para:

"use strict";

const fs = require("fs");
const path = require("path");
const { Sequelize } = require("sequelize");
const basename = path.basename(__filename);
const sequelize = require("../config/database.js");

const db = {};

fs.readdirSync(__dirname)
  .filter((file) => {
    return (
      file.indexOf(".") !== 0 && file !== basename && file.slice(-3) === ".js"
    );
  })
  .forEach((file) => {
    const model = require(path.join(__dirname, file))(
      sequelize,
      Sequelize.DataTypes
    );
    db[model.name] = model;
  });

Object.keys(db).forEach((modelName) => {
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

db.sequelize = sequelize;
db.Sequelize = Sequelize;

module.exports = db;

O próximo passo é configurar o Sequelize para encontrar os arquivos nas pastas pra onde os movemos, para isso na raiz do projeto crie um arquivo .sequelizerc e insere nele esse conteúdo obs:(o arquivo será formatado com a extensão Plain Text no vscode altere para Js):

const path = require('path');
module.exports = {
    'config': path.resolve(__dirname, 'src', 'config', 'config.js'),
    'models-path': path.resolve(__dirname, 'src','models'),
    'seeders-path': path.resolve(__dirname, 'src', 'db', 'seeders'),
    'migrations-path': path.resolve(__dirname, 'src', 'db', 'migrations')
};

O próximmo passo é alterar o src/index.js para:

const express = require("express");
const database = require('./config/database');
const router = require('./router');

const app = express();

const configureExpress = () => {
    app.use(express.json());
    app.use(express.urlencoded({ extended: true }));
    app.use("/", router);
    return app;
  };

module.exports = database.authenticate().then(configureExpress);

Com essa alteração, a aplicação só rodará caso a conexão com o bando de dados tenha ocorrido com sucesso.

Altere app.js para:

const setApp = require("./src");
setApp
  .then((app) =>
    app.listen(3000, () => console.info("app running on port 3000"))
  )
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

O projeto está devidamente configurado, agora precisamos criar os models, migrations, controllers e as rotas. Primeiro, vamos gerar as migrations e model a base dados vai ser duas tabelas uma de account e a do usuário e haverá um relacionamento de um para um, no caso o usuário possui uma conta, então vamos gerar primeiro um migrations e model chamada de account e em seguida a do user, vamos para o código:
comando para gera um model

npx sequelize-cli model:generate --name Account --attributes name:string,planLevel:string

Model gerado:

'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Account extends Model {
    static associate(models) {
    }
  };
  Account.init({
    name: DataTypes.STRING,
    planLevel: DataTypes.STRING
  }, {
    sequelize,
    modelName: 'Account',
  });
  return Account;
};

Vemos que não gerei o id, pois, ele é auto-incremento, então não precisamos dele aqui no model, ótimo pra quem for usar um id com número, mas pra quem for usar com uuid tem que realizar algumas alterações no model, pois, o Postgres com Sequelize não gera automaticamente para isso vamos fazer essas seguintes alterações :

'use strict';
const {
  Model
} = require('sequelize');
module.exports = (sequelize, DataTypes) => {
  class Account extends Model {
    static associate(models) {}
  };
  Account.init({
    id: {
      type: DataTypes.UUIDV4,
      autoIncrement: true,
      primaryKey: true,
      defaultValue: DataTypes.UUIDV1,
    },
    name: DataTypes.STRING,
    planLevel: DataTypes.STRING
  }, {
    sequelize,
    modelName: 'Account',
  });
  return Account;
};

Vamos fazer o mesmo com o model do User e em relação com o uuid é a mesma forma no model do User, execute esse comando:

npx sequelize-cli model:generate --name User --attributes firstName:string,lastName:string,email:string,password:string

Pronto, os devidos models já foram criados, e automaticamente as migrations já foram criadas, e agora precisamos alterar o id do migrations para uuid e adicionar um column no user realizando um relacionamento com account o nome do campo account_id.

Migrations

No banco de dados relacional é uma coleção de dados que já tem uma estrutura de relacionamento predefinidos com uma organização de linhas e colunas. Vamos imaginar que estamos trabalhando em uma equipe com um banco de dados relacional e por algum motivo mais de uma pessoa está utilizando a mesma tabela. Para adequar a uma necessidade que surgiu um deles precisa que o telefone do usuário na tabela seja representado como um inteiro e não uma string, então ele dá um push em desenvolvimento e quebra a atividade do companheiro de equipe.
Percebe o quanto isso pode quebrar a produtividade quando falamos em trabalho em equipe? É exatamente por isso que as migrations foram criadas para ser um controle de versionamento de um estado para outro dos bancos de dados, assim como o GIT é para código da aplicação.
Migrations
migrations do acccount:

'use strict';
module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.createTable('Accounts', {
      id: {
        allowNull: false,
        primaryKey: true,
        default: Sequelize.UUID,
        type: Sequelize.UUID
      },
      name: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      planLevel: {
        type: Sequelize.STRING,
        allowNull: false,
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      }
    });
  },
  down: async (queryInterface, Sequelize) => {
    await queryInterface.dropTable('Accounts');
  }
};

migrations do user:

'use strict';
module.exports = {
  up: async (queryInterface, Sequelize) => {
    await queryInterface.createTable('Users', {
      id: {
        type: Sequelize.UUID,
        allowNull: false,
        primaryKey: true,
        default: Sequelize.UUID,
      },
      firstName: {
        type: Sequelize.STRING,
        allowNull: false
      },
      lastName: {
        type: Sequelize.STRING,
        allowNull: false
      },
      email: {
        type: Sequelize.STRING,
        allowNull: false
      },
      password: {
        type: Sequelize.STRING,
        allowNull: false
      },
      account_id: {
        type: Sequelize.UUID,
        allowNull: false,
        default: Sequelize.UUID,
        references: {
          model: "Accounts",
          key: "id",
        },
        onUpdate: "CASCADE",
        onDelete: "CASCADE",
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      }
    });
  },
  down: async (queryInterface, Sequelize) => {
    await queryInterface.dropTable('Users');
  }
};

Após gera e fazer todas as alterações necessárias em migrations e model agora precisamos executar esse comando para criar as tabelas no bando:

npx sequelize-cli db:migrate

O projeto já está mais da metade resolvida, o precisamos agora é desenvolver as rotas, regra de negócio e o relacionamento entre as tabelas. Primeiro, vamos fazer o relacionamento entre as tabela, nisso precisamos ir à pasta do models/user e models/account para realizar algumas alterações. Lembrando que precisamos criptografar a senha do usuário antes de salvarmos esse dado no nosso banco de dados, então vamos primeiro para models/user:

//em associate adiciona esse código para fazer o relacionamento entre as tabelas 
static associate(models) {
      this.belongsTo(models.Account, { foreignKey: "account_id", as: "accounts" });
    }
//após o modelName: "User", adicione esse código para que antes dele criar o usuário ele criptografar o valor da senha 
hooks: {
    beforeCreate: (user, options) => {
        return bcrypt
        .hash(user.password, 10)
        .then((hash) => {
             user.password = hash;
        })
        .catch((err) => {
            throw new Error(err);
        });
    },
},

No models/account, vamos alterar o associate para:

static associate(models) {
    this.hasOne(models.User, { foreignKey: "account_id", as:"accounts"});
}

Esse é um relacionamento de um pra um, então estou usando hasOne caso fosse de um pra muitos devemos utilizar hasMany.

Caso precise mudar o nome da tabela em migrations

você gera outra migrations com um nome que indique o que essa migrations representa. O primeiro argumento é um nome da tabela que está no banco de dados, e o segundo argumento é o nome que a tabela receberá.
example:

'use strict';
module.exports = {
  up: async (queryInterface, Sequelize) => {  
    await queryInterface.renameTable('accounts', 'Accounts');   
  },

  down: async (queryInterface, Sequelize) => {
     await queryInterface.dropTable('Accounts');     
  }
};

Saiba Mais

Router e Controller

Agora vamos finalizar o projeto criado as rotas da api, mas primeiro vamos criar dos arquivos na pasta controller um chamado de controller/Account.js e controller/User.js. Nesses arquivos estarão a regra de negócio do projeto e a comunicação com o banco de dados. Nome do arquivo com letra maiúscula, pois, vamos criar uma classe.
controller/Account.js

const model = require("../models");
class Account {
  async store(DAO) {
    try {
      const account = await model.sequelize.models.Account.create({
        name: DAO.name,
        planLevel: DAO.planLevel,
      });
      return account;
    } catch (error) {
      throw new Error(error);
    }
  }

  async show() {
    try {
      const accounts = await model.sequelize.models.Account.findAll();
      return accounts;
    } catch (error) {
        throw new Error(error);
    }
  }
}

module.exports = Account;

controller/User.js

const model = require("../models");
class User {
  async store(DAO) {
    try {
      const user = await model.sequelize.models.User.create({
        firstName: DAO.firstName,
        lastName: DAO.lastName,
        email: DAO.email,
        password: DAO.password,
        account_id: DAO.account_id,
      });
      return user;
    } catch (error) {
      throw new Error(error);
    }
  }
    //no attributes informo os campos que eu quero que retorna do select
    ///include estou incluido a associação feita com o account, então ele vai retornar o account daquele user
  async show() {
    try {
      const users = await model.sequelize.models.User.findAll({
        attributes: ['id', 'firstName', 'lastName', 'email', 'account_id'],
        include: {
          attributes: ['id', 'name'],
          association: "accounts",
        },
      });
      return users;
    } catch (error) {
      throw new Error(error);
    }
  }
}

module.exports = User;

Para finalizar o Projeto, vamos fazer as rotas primeiro precisamos criar dos arquivos na pasta router um chamado de router/user.js e router/account.js no arquivo router/account.js fica o seguinte código:

const { Router } = require("express");
const AccountController = require("../controller/Account");
const accountController = new AccountController();
const router = Router();

router.get("/", async (req, res) => {
  try {
    const result = await accountController.show();
    res.status(200).send(result);
  } catch (error) {
    res.status(400).send(error);
  }
});

router.post("/", async (req, res) => {
  try {
    const result = await accountController.store(req.body);
    res.status(200).send(result);
  } catch (error) {
    res.status(400).send(error);
  }
});

module.exports = router;

no router/user.js

const { Router } = require("express");
const UserController = require("../controller/User");
const userController = new UserController();
const router = Router();

router.get("/", async (req, res) => {
  try {
    const result = await userController.show();
    res.status(200).send(result);
  } catch (error) {
    res.status(400).send(error);
  }
});

router.post("/", async (req, res) => {
  try {
    const result = await userController.store(req.body);
    res.status(200).send(result);
  } catch (error) {
    res.status(400).send(error);
  }
});

module.exports = router;

No arquivo router/index.js temos que adicionar as rotas criadas, então fica assim o arquivo router/index.js.

const { Router } = require("express");
const user = require('./user');
const account = require('./account');

const router = Router();

router.use('/user', user);
router.use('/account', account);
router.get('/', async (req, res) => {
    res.send('api running!'); 
});

module.exports = router;

Portanto, o projeto está pronto!
Referências:
Orlando, Claudio. Configurando o ORM Sequelize no NodeJS com ExpressJS. Rocketseat, 2017. Disponivel em: https://blog.rocketseat.com.br/nodejs-express-sequelize/. Acesso em: 18, Fev. de 2021
Node.js - O que é, como funciona e quais as vantagens.A Opus Software, 2018. Disponivel em: https://www.opus-software.com.br/node-js/. Acesso em: 22 de Fev. de 2021.