DEV Community: Matheus Viana

Migração NodeJS por .Net Core (Considerações)

Matheus Viana — Mon, 25 Jan 2021 21:44:47 +0000

Bom, em dezembro de 2020 fiz uma mudança em minha vida mudança qual inclui uma nova stack de trabalho. Eu sempre vi linguagens de programação como ferramentas onde todas seguem uma ideia parecida e você tem que aprender somente a sintaxe, ao sair de um ambiente 100% Javascript a primeira boa impressão é a organização que o framework .net traz para o c# e segundo a produtividade que é alcançada com o VisualStudio. Não faz muito tempo que estou nessa stack logo não tenho muito o que comentar. Mais para o meio do ano pretendo fazer outro post mais estruturado e contendo mais considerações.

Nesse meio tempo para quem está disposto a seguir com .net core eu vou deixar alguns cursos que estou fazendo e já acabei:

Criar paginação para um App feito com NodeJS

Matheus Viana — Sun, 03 May 2020 13:23:54 +0000

Hey,

Estou inspirado desde da semana passada em criar um blog pessoal para mim, onde vou falar de tecnologia e outras coisas, e como todo bom blog temos uma paginação para não termos uma bad UX, estou utilizando a seguinte stack no backend:

NodeJS;
Docker;
MongoDB;
Jest para testar meu código.

Bom, para o Mongo estou usando o ODM Mongoose. Let's code.

Paginação nada mais é do que pularmos uma porção de resultados e podendo configurar um limite para o tanto de resultados que serão pulados por página. Exemplo: pagina=2&limite=10 página 1 = 0 ~ 10, página 2 = 11 ~ 20.
Observando o exemplo podemos notar que estamos pulando 10 resultados por página, agora vamos codar isso, eu vou pegar um techo de código do projeto que estou fazendo e vou explicar para vocês:
controller.js

exports.getAllPosts = async (req, res) => {
  try {
    // Aqui pegamos pelos query params a página que queremos e como query params
    // vêm em string convertemos para números e caso seja vazio estamos settando para 1

    const pagina = +req.query.page || 1;

    // Aqui estamos pegando o limite informado pelos query params e 
    // convertendo para número caso seja vazio settamos para 10 

    const limite = +req.query.limit || 10;

    // Aqui rola um cálculo maroto, onde subtraimos para pegarmos a página anterior e multiplicamos pelo limite
    // para termos o salto desejado;

    const salto = (pagina - 1) * limite;

    // Aqui fazemos a pesquisa no nosso banco e realizamos a paginação.
    // Skip e Limit que estão no chaining do documento são metodos do Mongoose
    const post = await Post.find().skip(salto).limit(limite);

    res.status(200).json({
      status: 'sucesso',
      post,
    });
  } catch (err) {
    // ...error Handling
  }
};

Ok, Matheus você nos mostrou como fazer páginação, mas tem como testar essa função que você fez? A resposta curta é sim!

controller.spec.js

describe('GET METHOD', () => {
  it('Gets page 3 with the limit of 1 result', async () => {
    const response = await request(app).get('/v1/posts?pagina=3&limite=1');

    expect(response.status).toBe(200);
    expect(response.body.post[0].status).toBe('public');
    expect(response.body.post[0].title).toBe('Teste teste tese teste');
    expect(response.body.post[0].body).toBe(
      'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.',
    );
    expect(response.body.post[0].metaDescription).toBe(
      'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliq',
    );
  });
});

E isso é tudo pessoal.

Qualquer dúvida é só deixar nos comentários que responderei.

Projeto: https://github.com/moviandev/blog-backend
GitHub: https://github.com/moviandev/
LinkedIn: https://www.linkedin.com/in/matheusviana/

Até a próxima!

Popular banco de dados MySQL para testes de integração.

Matheus Viana — Sun, 03 May 2020 01:44:47 +0000

Hey,

Escrevo esse artigo para ajudar os outros devs que passaram por uma situação parecida com a que tive no projeto que estou atuando. Dockerizamos todos os nossos testes tanto os de unidade quanto os de integração (Sistêmicos), porém para realizarmos os testes de integração era necessário criarmos e popularmos o banco de dados, pesquisamos em vários fóruns e de todas as formas possiveis e nada foi encontrado, então resolvi fazer uma POC que solucionou nossos problemas e nela foi utilizado:

NodeJS;
Package do MySQL;
Docker.

Antes de começarmos uns pontos a se atentar:

Tinha um arquivo com todas as Queries SQL para criação do banco e das tabelas, um inserindo dados mockados e outro para derrubar todas as tabelas.

Script em Javascript usando o Package MySQL

const mysql = require('mysql');
const fs = require('fs');

// Aqui usei uma IIFE e uma função anonima, para nenhum metodo desse arquivo seja usado fora dele
(async function() {
  try {
    // Aqui realizamos a conexão com o banco de dados MySQL
    const mysqlConn = await mysql.createConnection({
      host: process.env.MYSQL_HOSTNAME,
      port: process.env.MYSQL_PORT,
      user: process.env.MYSQL_USER,
      password: process.env.MYSQL_PASSWORD,
      database: process.env.MYSQL_DATABASE,
      // Como os arquivos com as queries tinham várias declarações eu settei para true o mesmo 
      multipleStatements: true,
    });

    // Aqui connecto com mysql
    await mysqlConn.connect();

    // Esse primeiro método ele cria o banco de dados caso não exista e cria as tabelas do banco
    const createTablesNDB = async () => {
      try {
        const tablesNDB = fs.readFileSync(`${__dirname}/database.sql`, 'utf8');
        await mysqlConn.query({ sql: tablesNDB.toString() });
        // Aqui settei um timeout por algum motivo o script estava pulando para o process.exit()
        setTimeout(() => {
          process.exit();
        }, 1500);
      } catch (err) {
        console.log(err);
      }
    };

    // Nesse método é inserido os dados mockados nas tabelas criadas
    const inserirDados = async () => {
      try {
        const data = fs.readFileSync(`${__dirname}/_data.sql`, 'utf8');
        await mysqlConn.query({ sql: data.toString() });
        setTimeout(() => {
          process.exit();
        }, 1500);
      } catch (err) {
        console.log(err);
      }
    };

    // Nesse outro método é dropado todas as tabelas para não haver conflitos de FK, ao rodar o banco novamente e toda vez que forem executados os testes recriar o banco e as tabelas, para não viciarmos nossos testes
    const removerTabelas = async () => {
      try {
        const dropTables = fs.readFileSync(
          `${__dirname}/_drop.sql`,
          'utf8',
        );
        await mysqlConn.query({ sql: dropTables.toString() });
        setTimeout(() => {
          process.exit();
        }, 1500);
      } catch (err) {
        console.log(err);
      }
    };

    // Aqui criamos uma CLI simples onde possui 3 subcomandos
    // O process.argv ele é um array com os argumentos passados em um comando que no caso nosso comando seria $ node db.js --[create || insert || drop]
    if (process.argv[2] === '--create') {
      criarTabelaseBD();
    } else if (process.argv[2] === '--insert') {
      inserirDados();
    } else if (process.argv[2] === '--drop') {
      removerTabelas();
    }
  } catch (err) {
    // Aqui logamos todos os erros
    console.error('ERROR >>>>>>>>>>>', err, 'MESSAGE >>>>>', err.message);
  }
})();

Com esse arquivo você pode criar um arquivo .sh e passar a ordem dos comandos, exemplo:

#!/bin/bash

npm test &&
node ./db.js --drop &&
node ./db.js --create &&
node ./db.js --insert &&
npm run test:integration && 
node ./db.js --drop

No seu Dockerfile de testes na linha de CMD você pode rodar ["sh", "./tests.sh"] que o Docker fará toda mágica para você hehe, não esqueçam de settar o env-file caso estiver usando docker-compose e também de settar as variáveis de ambiente no seu arquivo de environment.

E é isso pessoal, adendo esse código é uma proof of concepts.

Qualquer dúvida é só deixar nos comentários que eu responderei.

LinkedIn: https://www.linkedin.com/in/matheusviana/
GitHub: https://github.com/moviandev

Até a próxima meus camaradas.

Integração continua com Travis-CI, NodeJS/NestJS

Matheus Viana — Sat, 02 May 2020 02:23:06 +0000

Hey,

Em tempos de Coronavírus eu e o meu amigo e colega de trabalho Rogério dos Santos decidimos escrever uma série de artigos para mostrarmos um Backend feito em NodeJS desenvolvido com carinho e boas práticas.

Nesse artigo vamos falar um pouco da primeira versão do nosso CI utilizando Travis.

Motivação

Sou um desenvolvedor de Software que tem uma paixão enorme pelo que faz. Como gostamos muito da comunidade Javascript/Typescript resolvemos fazer um projeto onde abordaremos boas práticas para produtos, são essas:

S.O.L.I.D;
TDD;
DDD [Domain-driven design];
Clean Code.

Agora que explicado a nossa motivação let's talk code.

Actually, ainda não, antes vou falar pouco do Travis. Travis é um serviço de CI que automatiza os testes do seu código.

Para usar o Travis é simples o que, a meu ver, é excelente. Vou fazer um passo-a-passo para ajudar vocês.

Passo 1 - Criando uma conta e instalando Travis no GitHub

Crie uma conta no Travis e logo após a criação da sua conta você será redirecionado(a) para a página de getting started, lá você ativará o Travis no repositório desejado ou você pode instalar no seu GitHub inteiro.

Passo 2 - Configurando Travis para um App NodeJS

Agora no repositório do projeto crie um arquivo com o nome .travis.yml
e pode ser aplicada as seguintes configurações:

language: node_js
node_js:
# Versão do node que é utilizada no projeto.
  - 12

# Script que tem que ser executado antes do antes do script "principal"
before_script:
# Pode ser usado npm ou yarn, escolhemos usar yarn.
  - yarn install

# Script "principal"
script:
# Script de teste encontrado no package.json
  - yarn test
# Script dos testes end-to-end
  - yarn run test:e2e

# Caso necessário você pode settar configurações para serem excutadas depois do script "principal" com a configuração # after_script #

Passo 3 - Final Step

Depois de tudo configurado é só dar git push e ir para https://travis-ci.com/github/usuario/repositorio para ver sua pipeline executando em toda sua perfeição.

Projeto: https://github.com/moviandev/geekLounge

E é isso pessoal, muito obrigado e até a próxima.

GitHub
LinkedIn