Vamos começar a desenvolver as funcionalidades do AluraDocs que, por enquanto, só tem as partes estáticas prontas.
Na atividade anterior já disponibilizamos para você o projeto inicial com as duas páginas HTML. Estou com esse projeto aberto no meu VS Code.
Dentro desse projeto temos um arquivo .gitgnore, para ignorar a pasta node_modules. Isso é caso você utilize Git, vamos ignorar essa pasta na hora de subir o projeto.
Também temos a pasta "public", que é a pasta onde estão os dois arquivos HTML: index.html, nela estou utilizando Bootstrap para a estilização, e nesta pasta também temos o documento.html. Você pode dar uma olhada com calma nesses arquivos HTML.
Para conseguirmos utilizar o protocolo WebSockets precisamos ter o servidor Node rodando.
Para fazer o projeto em Node vamos abrir o terminal integrado do VS Code com o atalho "Ctrl + J". E, no terminal faremos o comando npm init -y, o "Y" serve para responder "sim" às perguntas que o terminal faz ao criarmos um novo projeto em Node:
Ao executar esse comando, foi criado o arquivo package.json na raiz do nosso projeto.
Feito isso, podemos instalar o Express, que utilizaremos para fazer um servidor Node básico. Vamos baixar a versão 4 do Express.
Após executar esse comando podemos fechar o terminal integrado.
Se abrirmos o package.json veremos na parte de dependências que o Express foi instalado com sucesso na nossa aplicação.
"dependencies": {
"express": "^4.18.2"
}
Vou aproveitar que estou no package.json e vou adicionar, logo antes da parte de scripts, mais uma configuração de uma propriedade type com valor module para conseguirmos utilizar os módulos do ECMAScript para usarmos palavras-chaves como import e export.
"name": "alura-docs",
"version": "1.0.0",
"description": "",
"main": "index.js",
"type": "module",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
Vamos salvar o projeto, fechar o package.json e criar o arquivo do nosso servidor.
Na pasta raiz do projeto criaremos uma nova pasta chamada "src". Dentro da pasta "src" criaremos um arquivo chamado servidor.js. Começaremos importando o Express.
import express from "express";
Com isso, já conseguiremos criar um app do Express com a constante app recebendo express(). Em seguida vamos declarar a porta que vai receber process.env.porta ou 3000, colocaremos duas barras verticais (||) para indicar o "ou" do JavaScript.
import express from "express";
const app = express();
const porta = process.env.porta || 3000;
Agora podemos informar qual porta a app vai "escutar" com app.listen(), os parâmetros serão porta o segundo parâmetro será a função callback que pode executar um console.log() com uma template string informando que o servidor está escutando na porta, e faremos uma interpolação para inserir a constante porta ${porta}.
import express from "express";
const app = express();
const porta = process.env.porta || 3000;
app.listen(porta, () => console.log(`Servidor escutando na porta ${porta}`)
Agora precisamos adicionar um script em package.json após o script test. Adicionaremos o script dev e o valor dele será uma string com o valor node src/servidor.js.
"dev": "node src/servidor.js"
{
"name": "alura-docs",
"version": "1.0.0",
"description": "",
"main": "index.js",
"type": "module",
"scripts": {
"test": "echo "Error: no test specified" && exit 1",
"dev": "node src/servidor.js"
},
Podemos salvar o projeto. Vamos abrir o terminal do VS Code e executar o comando npm run dev para executar esse script.
O retorno no terminal foi:
Servidor escutando na porta 3000
Nosso servidor já está funcionando. Agora, vamos fazer o nosso servidor mostrar as páginas HTML que estão na pasta "public" do nosso projeto.
Para isso, vamos fazer algumas configurações.
Primeiro, vamos escrever no início do arquivo servidor.js importando a url e o path:
import express from "express";
import url from "url";
import path from "path";
const app = express();
const porta = process.env.porta || 3000;
app.listen(porta, () => console.log(`Servidor escutando na porta ${porta}`)
Em seguida, abaixo de const porta vamos pegar o caminho atual para navegar até o diretório da pasta "public". Usaremos url.fileURLToPath, que é um método do módulo URL, com o parâmetro import.meta.url.
const caminhoAtual = url.fileURLToPath(import.meta.url);
Isso vai nos dar exatamente o caminho atual de onde estamos até o servidor.js. Queremos navegar até a pasta "public", então escreveremos em seguida um const diretorioPublico que vai receber path.join onde passaremos como primeiro parâmetro o caminhoAtual e o segundo parâmetro será uma string subindo dois níveis a partir do caminho atual "../..". No primeiro par de pontos vamos sair do arquivo atual e ir para o diretório atual, que é a pasta "src", e no segundo par de pontos vamos subir mais um nível e ir para a pasta raíz do projeto.
Estando na pasta raiz, queremos navegar para a pasta "public": "../..", "public").
const caminhoAtual = url.fileURLToPath(import.meta.url);
const diretorioPublico = path.join(caminhoAtual, "../..", "public");
E, ao chegar no diretório "public" podemos fazer app.use passando express.static como parâmetro e o parâmetro de static será o diretorioPublico.
const caminhoAtual = url.fileURLToPath(import.meta.url);
const diretorioPublico = path.join(caminhoAtual, "../..", "public");
app.use(express.static(diretorioPublico));
Com esta última linha, app.use(express.static(diretorioPublico)), queremos informar que desejamos que o Express utilize o diretório público de forma estática e vamos poder disponibilizá-los no navegador.
Vamos salvar o arquivo que ficou assim:
import express from "express";
import url from "url";
import path from "path";
const app = express();
const porta = process.env.porta || 3000;
const caminhoAtual = url.fileURLToPath(import.meta.url);
const caminhoAtual = url.fileURLToPath(import.meta.url);
const diretorioPublico = path.join(caminhoAtual, "../..", "public");
app.use(express.static(diretorioPublico));
app.listen(porta, () => console.log(`Servidor escutando na porta ${porta}`)
Agora vamos pausar o servidor e executá-lo novamente.
Servidor escutando na porta 3000
Em seguida, vamos para o navegador e inserir na barra de endereço a URL:
E apareceu a página do AluraDocs! Nosso código funcionou corretamente. O servidor está mostrando no navegador.
Agora, vamos resolver aquele problema de ter que reiniciar o servidor sempre que fazemos alguma alteração no nosso projeto.
Para isso, utilizaremos a biblioteca nodemon, que vai nos ajudar a reiniciar o servidor automaticamente.
Podemos pausar o servidor com o comando ^C.
E escreveremos o comando para instalar a versão 2 do nodemon e também vamos inserir um traço seguido de um "D" maiúsculo para instalar o nodemon como dependência de desenvolvimento, porque não queremos que essa dependência vá para produção, ela servirá apenas para nos auxiliar no desenvolvimento.
Ao executar o comando o nodemon foi instalado. Podemos conferir no fim do arquivo package.json que o nodemon está instalado como dependência de desenvolvimento.
"devDependencies": {
"nodemon": "^2.0.20"
}
Por fim, para utilizar o nodemon de fato, vamos alterar o script dev, nele trocaremos "node" por "nodemon":
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"dev": "nodemon src/servidor.js"
},
Feito isso, podemos salvar o projeto. E ao abrir o terminal integrado e escrever o comando npm run dev receberemos o retorno de algumas linhas indicando que o nodemon está funcionando e ao salvar o projeto o servidor vai reiniciar automaticamente. Isso vai facilitar o desenvolvimento.
A partir do próximo vídeo começaremos a implementar as primeiras funcionalidades do AluraDocs utilizando protocolo WebSockets.