TodoList

Repositório principal do projeto TODOLIST-PROJ

Preparação do ambiente de trabalho

Preparar o ambiente do projeto NODE
1. Você deve instalar o editor, o git, configurar uma conta no github para poder executar os demais passos do seu projeto.
2. Após concluir todos os pre-requisitos acima continue
Iniciar projeto NODE

🗨️ No shell, utilizar o NPM (O Gerenciador de pacotes do node) com o comando acima, ele se encarrega de inicializar um projeto novo em node. o -y faz ele ignorar uma série de perguntas para começar o projeto. Será tudo automático!
```
npm init -y
```
🚦 Como saída teremos o arquvo package.json com as configurações básicas criadas. Todo pacote instalado no node será registrado no arquivo package.json.
Criar arquivo .GITIGNORE

🗨️ .gitignore - informa ao git para não commitar os caminhos, arquivos e outras informações que forem representados dentro do arquivo.
```
    node_modules/
```
🚦 Em seu editor de texto criar o arquivo .gitignore e dentro dele inserir a linha node_modules/ Como saída teremos o arquvo .gitignore com suas configurações básicas.
Instalar o EXPRESS

🗨️ o módulo Express – o mais usado e mais bem conhecido framework web node.js
```
    npm i -S express
```
🚦 No shell devemos digitar a linha acima ☝️ para instalação. Como saída teremos uma pasta /node_modules contendo o pacote instalado e todos as demais dependências. Também o arquivo package-lock.json e o server.js.

❗ O Registro abaixo 👇 foi criado dentro do arquivo package.json automaticamente.
```
    "dependencies": {
      "express": "^4.17.1"
    },
```
🚦 Caso você queira reinstalar os pacotes do node por algum motivo ou iniciar um projeto novo. Ele informará quais módulos deverão ser instalados. Basta executar o comando abaixo 👇 na sua linha de comandos.
```
    npm install
```
❗ Os módulos são bibliotecas JavaScript que você pode incluir no seu projeto. Sempre que você instalar um módulo do npm, ele será instalado na pasta node_modules/
Criar/Editar SERVER.JS

🗨️ _O arquivo server.js contém os scripts para execução do servidor de aplicação no node.
```
    const express = require('express')
    const app = express()
    app.listen(3001)
    console.log("servidor funcionando")
```
🚦 em seu editor de texto, criar ou editar o arquivo server.js e inserir o código acima. Vamos declarar duas constantes. A primeira importa o express e a segunda recebe o objeto express(). na instância criada app, vamos passar a porta 3001, através do método listen() e para facilictar a visualização do que está acontecendo vamos gerar uma mensagem de que está "tudo bem" através do console.log.
Instalar o Nodemon

🗨️ esse módulo é o utilitário que irá monitorar todas as alterações nos arquivos de nossa aplicação e reiniciar automaticamente o servidor quando for necessário.
```
    npm i -D nodemon
```
🚦 a cada alteração que fazemos em um arquivo, precisamos reiniciar a aplicação com o comando node script ou script.js. O -D serve para informar que queremos sua execução apenas em modo desenvolvimento. Para rodar nossos scripts no shell basta digitar nodemon script.js.

❗ O Registro de dependência abaixo 👇 foi criado dentro do arquivo do seu projeto package.json no momento da instalação do nodemon.
```
    "devDependencies": {
    "nodemon": "^2.0.4"
    }
```
Configurando o Nodemon

🗨️ Assim que iniciamos o NPM será lido o arquivo package.json ele contém vários blocos para serem carregados junto com o node.
```
"scripts": {
  "test": "echo \"Error: no test specified\" && exit 1",
  "start": "nodemon server.js"
},
```
🚦 O que iremos fazer é inserir dentro do bloco "scripts" uma álias start que ao ser chamada no shell junto com o comando node irá executar o sua declaração: "start": "nodemon server.js".

❗ O script "start": "nodemon server.js" foi criado dentro do bloco "script" no arquivo package.json.
Inicializando o nodemon

🗨️ Como NPM támbem é responsável pela gerencia de dependências do projeto vamos chamá-lo para executar o script "start".
```
    npm start
```
🚦 No prompt de comandos vamos digitar npm start o nodemon irá executar o server.js e ficará monitorando qualquer alteração no projeto a fim de reiniciá-lo automaticamente.
Melhorando o server.js

🗨️ Agora com o nodemon de olho em tudo, vamos melhorar nosso server.js alterando duas linhas.
```
    const port = process.env.PORT || 3000;

    app.listen(port);

    console.log('servidor funcionando, na porta:', port);
```
🚦 em seu editor de texto, vamos alterar o arquivo server.js e modificar as constantes e a linha console.log com o código acima ☝️.
Usar o bodyParser

🗨️ O body-parser é um módulo disponibilizado no Framework Express capaz de converter o body da requisição para vários formatos e justamente por isso vamos incrementar o server.js
```
    const express = require("express");
    const app = express();
    const port = process.env.PORT || 3000;
    const routes = require("./src/api/routes/usuarioRoutes.js")
...
// inserindo aqui o body-parse:
    const bodyParser = require("body-parser");
    app.use(bodyParser.json());
    app.use(bodyParser.urlencoded({ extended: false }));
...
    app.listen(port);
```
🚦 em seu editor de texto, vamos alterar o arquivo server.js vamos usar o BodyParser após a requisição: express , através do express com o seu módulo app.use() que iremos receber os recursos do bodyParser.

❗ certifique-se de que instalou o módulo npm denominado 'body-parser' chamando:
```
npm install body-parser --save
```
Rotas com Express

🗨️ Inserir a primeira rota básica apenas para informar que a rota está funcionando
```
    app.route('/').get((req, res)=>{res.send('API todoList - Certo no método GET')});
```
🚦 em seu editor de texto, vamos alterar o arquivo server.js vamos inserir o app.route(), abaixo das requisições: . Teremos nossa primeira rota que é do tipo “get”. Ela é composta de dois parâmetros, o primeiro é o endereço da nossa rota, no caso a raiz da aplicação .route("/), já o segundo é uma função de retorno, que recebe também dois parâmetros o “req” (requisição) e o “res” (resposta), nessa função retornamos uma simples mensagem com o método “send” do Express.

❗ certifique-se de inserir route após as requisições anteriores: express e body-parser
Informando o caminho da aplicação

🗨️ Criar pastas principal da aplicação (api), as subpastas (controllers models routes) e os dois arquivos
```
    mkdir api

    cd api

    mkdir controllers models routes
```
🚦 api: Esta pasta contém toda a parte lógica e estrutural de nossa aplicação, é nela que definimos nossos controllers, models, routes, enums, util, helpers. api/controllers: Responsável por armazenar todos os controllers de nossa aplicação, centralizados em um único lugar. Geralmente é onde encontramos algumas das regras de negócio. api/models: Responsável por armazenar todos as models da nossa aplicação, que neste projeto serão as classes de instâncias do ORM SEQUELIZE.
Editando Rota e chamando o controller

🗨️ No arquivo usuarioRoutes.js vamos apontar para o controller Usuário
```
    module.exports = function(app){
        const usuarioR = require("../controllers/usuariosController.js")
        app.route("/usuarios")
        .get(usuarioR.listartodos)
        .post(usuarioR.criaregistro)
    }
```
🚦 Em seu editor de texto, vamos criar o arquivo usuarioRoutes.js em ./src/api/routes internamente usar o modulo.exports para disponibilizar a função para outros arquivos. Instanciar o objeto usuarioR chamadno o arquivo (usuariosController.js)) em ../controllers/ passando os médotos get(listartodos) e post(criarregistro).

Após criar o arquivo usuarioRoutes.js, retornar ao server.js e inserir a chamada para a função app logo abaixo das instância app. conforme script abaixo 👇
```
    routes(app);
```
❗ Observe que instanciamos o objeto usuarios apontando para um arquivo que ainda não existe "../controllers/usuariosController.js", é o que vamos fazer logo abaixo.

Editando Controller

🗨️ No arquivo usuariosController.js vamos criar duas funções: a primeira listas os registros e a segundo criar registros

const UsuarioC = require("../models").Usuarios

    exports.listartodos = (req, res) =>{
      UsuarioC.findAll().then(usuariosC=>{
            res.send(usuariosC);  
      }).catch(error=>{ })

    }

    exports.criaregistro = (req, res) =>{
      console.log(UsuarioC)
      const {nome,email} = req.body
      UsuarioC.create({nome,email}).then(UsuarioC=>{
            res.send(UsuarioC)
      }).catch(error=>{res.send(error)})

    }

SqlLITE BANCO DE DADOS

🗨️ Como estamos em fase de modelagem vamos trabalhar inicialmente com SQLite.

SQLite
```
   npm i -S sqlite3
```
ou Postgres
```
npm i -S pg pg-hstore
```
ou SQL Server
```
npm i -S tedious
```
Sequelize

🗨️ é um ORM (Object-Relational Mapper) para Node.js. Eles faz o mapeamento de dados relacionais (armazenados tabelas, linhas e colunas) para objetos em JS. Ele permite criar, buscar, alterar e remover dados do banco usando objetos e métodos em JS, além de fazer alterações na estrutura das tabelas. Ele suporta os bancos PostgreSQL, MySQL, MSSQL e SQLite. Esse tipo de esquema sempre teremos um arquivo de configuração, responsável por fornecer os dados para que o componente de ORM possa se comunicar com o banco e aplicação.
```
   npm i -S sequelize
```
🚦 SEQUELIZE é um ORM(Mapeamento Objeto Relacional), sua base consiste em manter o uso de orientação a objetos e um pouco do conceito de non-query. Pois serão raros os momentos onde teremos que escrever uma linha de código SQL. Operam como um agente de banco de dados, sendo possível através de pouquíssimas mudanças, utilizar o mesmo código para mais de um banco de dados. Não importa se ele está em PostgreSQL, SqlServer ou até mesmo SQlite! você só precisa mudar o driver de conexão e está pronto para uso.

❗ Referências: Introdução ao Sequelize, node, express, postres usando Sequelize.
Sequelize CLI

🗨️ o Sequelize-CLI será utilizado apenas no ambiente de desenvolvimento.
```
   npm i -D sequelize-cli
```
🚦 No shel utilizando o gerenciador de pacotes NPM, vamos instalar o SEQUELIZE-CLI com a flag -D para ser utilizado apenas no ambiente de desenvolvimento.

❗ Lembramos que tanto o sequelize como sequelize-cli foram inseridos dentro do arquivo package.json em duas áreas diferentes "sequelize" ==> "dependencies" e o "sequelize-cli" ==> "devDependencies".
.sequelizerc

🗨️ personalizar o Sequelize em nosso projeto.
```
    const path = require('path');

    module.exports = {
        "config": path.resolve('./src/database/config', 'config.json'),
        "models-path": path.resolve('./src/api/models'), // respeitar MVC
        "seeders-path": path.resolve('./src/database/seeders'),
        "migrations-path": path.resolve('./src/database/migrations')
    };
```
🚦 Para configurar o sequelize, crie um arquivo na raiz do seu projeto, com o nome .sequelizerc. Em seu editor de texto, inserir algumas configurações de caminho das pastas do nosso projeto. Seu arquivo .sequelizerc deverá conter o seguinte conteúdo acima ☝️.

O config.json ==> contém configuração de autenticação do banco de dados. migrations ==> A pasta conterá as migrações de nosso aplicativo. models ==> os modelos de aplicativos (Na arquitetura MVC, o model é a representação da tabela do banco de dados). *seeders ==> Os dados de semente (são dados iniciais fornecidos com um sistema para fins de teste, treinamento ou modelagem).

❗ Referências: Respeitando o padrão MVC o "models" ficará na pasta /api. Nesta pasta será criado automaticamente um arquivo chamado index.js, nele consta script que verifica todos arquivos inseridos na pasta models e gera exportação para ser utilizado por outros arquivos. Para as demais pastas, irei colocar o config, seeders e migrations na pasta /database.
Iniciar o sequelize

🗨️ Iniciar o Sequelize com o npx.
```
   npx sequelize init
```
🚦 No shel utilizando o inicializador de pacotes NPX iremos iniciarlizar o sequelize

❗ O "npx" é o comando que inicializa sem obrigação de instalar pacotes.

Conexão com Banco SQLite

🗨️ Configurando a conexão com o banco no ./src/database/config/config.json. As configurações abaixo são criadas por padrão

   {
    "development": {
        "username": "root",
        "password": null,
        "database": "database_development",
        "host": "127.0.0.1",
        "dialect": "mysql"
    },
    "test": {
        "username": "root",
        "password": null,
        "database": "database_test",
        "host": "127.0.0.1",
        "dialect": "mysql"
    },
    "production": {
        "username": "root",
        "password": null,
        "database": "database_production",
        "host": "127.0.0.1",
        "dialect": "mysql"
    }
   }

🚦 Iremos trabalhar com SQLlite e por iremos modificar o arquivo acima ☝️ pelo modelo

❗ O arquivo config está em formato "json".

{
    "development": {
        "storage": "./src/database/database.sqlite3",
        "dialect": "sqlite"
    },
    "test": {
        "storage": "./src/database/database.sqlite3",
        "dialect": "sqlite"
    },
    "production": {
        "storage": "./src/database/database.sqlite3",
        "dialect": "sqlite"
    }
  }

Modelo associativo da TABELA no Sequelize

🗨️ Criando um modelo associativo de uma tabela Usuario no no Sequelize. para ser posteriormente migrado para o banco de dados
```
   npx sequelize model:generate --name Usuarios --attributes nome:string,email:string
```
🚦 O comando acima ☝️ vai gerar 2 arquivos: o_model ==> ./src/api/models/usuarios.js migration ==> .//src/database/migrations/"timestamp"-create-usuarios.js"_.

...

o Arquivo usuarios.js - é o modelo associativo do sequelize para com o banco.
O Arquivo "timestamp"-create-usuario.js internamente possui dois atributos a mais inseridos pelo próprio sequelize que é (createdAt / updatedAt) garantindo informaçoes sobre criação e atualização de cada registro na tabela.

❗ .//src/database/migrations/"timestamp"-create-usuario.js" não deve ser alterado. Nele consta detalhes da operação realizada, se foi operação de criação e seu timestamp. timestamp: representa um ponto específico na linha do tempo e leva em consideração o fuso horário em questão (UTC). Com isto, teremos sempre o detalhamento perante a linha do tempo real. ... :exclamation: "POR PADRÃO" o SEQUELIZE cria o nome da tabela no plural. Quando executei o comando (...model:generate --name usuario ...) foi criado o arquivo em .//src/database/migrations/"timestamp"-create-usuario.js nele constava "queryInterface.createTable('Usuarios'), { "Usuários" - a primeira letra em maiúscula e o acrescimo do 's' no final }.
Migrando Tabela modelo para o banco

🗨️ Criando uma tabela Usuario no banco database.sqlite3 pelo shel utilizando o Sequelize-cli.
```
   npx sequelize db:migrate
```
🚦 O arquivo "src\database\config\config.json", foi acionado e estabelecida a conexão e na sequência o arquivo de banco de dados "./src/database/database.sqlite3" foi alterado com a inclusão da tabela usuario.
Alterar Tabela

🗨️ migrations foram criadas para ser um controle de versionamento de um estado para outro dos bancos de dados.
```
   npx sequelize migration:create --name usuario-add-senha
```
🚦 Vamos para o shell e digitar a linha acima ☝️. Será gerado o arquivo src/database/migrations/timestamp-usuario-add-senha.js.

❗ Neste arquivo modelo iremos fazer algumas alterações antes de gravarmos no banco de dados.

Fazendo a alteração no arquivo migration

🗨️ Vamos alterar o arquivo migração criado por nós.

🚦 Vamos abrir o arquivo src/database/migrations/timestamp-usuario-add-senha.js. Em um editor de texto inserir o script abaixo 👇, que tem o nome da tabela "Usuarios" e o novo campo "senha" declarados

   'use strict';

    module.exports = {
    up: async (queryInterface, Sequelize) => {
        return Promise.all([
        queryInterface.addColumn(
            'Usuarios',
            'senha',
            {
            type: Sequelize.STRING
            }
        )

        ]);
    },

    down: async (queryInterface, Sequelize) => {
        return Promise.all([
        queryInterface.removeColumn('Usuarios','senha')
        ]);
    }
    };

❗ Neste arquivo iremos fazer algumas alterações nos módulos up e down. UP - é a função que indica o que modificar no banco de dados quando executarmos a migration e a DOWN, que funciona como um rollback, ou seja, tudo que for feito na up deve ser desfeito na down.

Enviando para o banco físico

🗨️ O Sequelize-cli irá popular na tabela Usuarios o campo senha declalarado no arquivo migration
```
   npx sequelize db:migrate
```
🚦 O comando acima ☝️ migration ==> .//src/database/migrations/"timestamp"-create-usuario.js".
Nova Tabela Lista no Sequelize

🗨️ Criando um modelo associativo de uma tabela Usuario no no Sequelize. para ser posteriormente migrado para o banco de dados
```
   npx sequelize model:generate --name Listas --attributes titulo:string,usuarioId:integer
```
🚦 O comando acima ☝️ vai gerar 2 arquivos: o model ==> ./src/api/models/usuario.js e o migration ==> .//src/database/migrations/"timestamp"-create-usuario.js". ... os models são a representação das tabelas do banco de dados em forma de classe.

❗ .//src/database/migrations/"timestamp"-create-usuario.js" não deve ser alterado. Nele consta detalhes da operação realizada, se foi operação de criação e seu timestamp. timestamp: representa um ponto específico na linha do tempo e leva em consideração o fuso horário em questão (UTC). Com isto, teremos sempre o detalhamento perante a linha do tempo real.

No momento todo o trabalho está a cargo de E-mail 📧 [email protected]

🟢 Foi criado o Grupo 25 - Para dar continuidade ao projeto ... 🚩 Trabalho foi desenvolvido como modelo de aprendizagem por @aquilesrodrigues TodoList-PROJ.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

TodoList

Repositório principal do projeto TODOLIST-PROJ

Preparação do ambiente de trabalho

About

Releases

Packages

Languages

Name		Name	Last commit message	Last commit date
Latest commit History 66 Commits
.vscode		.vscode
src		src
.gitignore		.gitignore
.sequelizerc		.sequelizerc
README.md		README.md
modelagem_sql.md		modelagem_sql.md
package-lock.json		package-lock.json
package.json		package.json
server.js		server.js

aquilesrodrigues/TodoList

Folders and files

Latest commit

History

Repository files navigation

TodoList

Repositório principal do projeto TODOLIST-PROJ

Preparação do ambiente de trabalho

About

Resources

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages