Configurando o Ambiente de Desenvolvimento Hapi.js com ServBay

O Hapi.js é um framework Node.js poderoso e flexível, ideal para construir aplicações e APIs. O ServBay fornece um ambiente de desenvolvimento local prático para desenvolvedores Node.js, integrado com runtime Node.js, múltiplos bancos de dados e servidores web fáceis de configurar. Este guia mostrará como criar e rodar projetos Hapi.js usando o ServBay, configurar o recurso de Sites para acesso via navegador, e como conectar aos bancos de dados integrados do ServBay.

O que é Hapi.js?

Hapi.js é um framework Node.js robusto e flexível, desenvolvido pelo Walmart Labs para criar aplicações e serviços. Ele se destaca por seu sistema poderoso de plugins, abordagem orientada à configuração e recursos de segurança embutidos — facilitando para desenvolvedores criarem aplicações web e APIs de alto desempenho e fáceis de manter.

Principais características e benefícios do Hapi.js

• Sistema de Plugins: Hapi.js conta com um sistema de plugins robusto e intuitivo, facilitando a extensão do framework ou a organização da lógica em módulos reutilizáveis.
• Abordagem Configurável: Promove o desenvolvimento orientado por configuração, permitindo definir rotas, validação, cache e outros comportamentos em detalhes.
• Validação de Entrada: Traz a poderosa biblioteca Joi embutida, para validação declarativa de dados, garantindo a integridade e a segurança.
• Ecossistema Rico: Possui uma comunidade ativa e uma variedade de plugins oficiais e de terceiros, abrangendo autenticação, autorização, cache, logs e muito mais.
• Segurança: Diversos recursos de segurança vêm de fábrica, ajudando a evitar ameaças comuns da web, como validação de entrada e controle de CORS.
• Logs e Debug: Fornece logs detalhados para o ciclo de vida das requisições e ferramentas de depuração.

Utilizando o Hapi.js, o desenvolvedor pode focar na lógica de negócio, deixando para o framework o tratamento da complexidade do HTTP, das rotas, validação e segurança.

Criando um Projeto Hapi.js com ServBay

Esta seção guia você na criação e execução de um projeto básico Hapi.js utilizando o ambiente Node.js do ServBay, acessando-o pelo recurso Sites (proxy reverso) do próprio ServBay.

Pré-requisitos

Antes de começar, verifique se:

1. O ServBay já está instalado no seu macOS.
2. O pacote Node.js está habilitado no ServBay. Ative em "Pacotes" no painel do ServBay.
3. Você possui conhecimento básico de terminal e npm (gerenciador de pacotes do Node.js).

Criando um Projeto Hapi.js

1. Inicialize o diretório do projeto

   Abra o terminal, acesse o diretório raiz de sites sugerido pelo ServBay: /Applications/ServBay/www. Crie uma nova pasta de projeto (ex: servbay-hapi-app) e entre nela:

   cd /Applications/ServBay/www
   mkdir servbay-hapi-app
   cd servbay-hapi-app

2. Inicialize o projeto Node.js

   No diretório do projeto, execute:

   npm init -y

   Isso criará o arquivo package.json na raiz do projeto.

3. Instale a dependência Hapi.js

   Instale o núcleo do Hapi.js usando npm:

   npm install @hapi/hapi

   O @hapi/hapi será adicionado às dependências do seu projeto.

4. Crie o arquivo principal da aplicação

   Crie um arquivo chamado server.js e adicione o seguinte código para rodar um servidor Hapi.js simples:

   'use strict'; // Ativa o modo estrito
   
   const Hapi = require('@hapi/hapi');
   
   const init = async () => {
   
     const server = Hapi.server({
       port: process.env.PORT || 3000, // Porta padrão: 3000, ou definida pela variável de ambiente PORT
       host: 'localhost' // Escuta apenas no endereço de loopback
     });
   
     // Define uma rota principal simples
     server.route({
       method: 'GET',
       path: '/',
       handler: (request, h) => {
         return 'Hello from Hapi.js powered by ServBay!';
       }
     });
   
     // Inicia o servidor
     await server.start();
     console.log('Server running on %s', server.info.uri);
   };
   
   // Lida com erros de Promise não capturados
   process.on('unhandledRejection', (err) => {
     console.error(err);
     process.exit(1); // Encerra o processo
   });
   
   // Inicia a aplicação chamando init
   init();

   Este código sobe um servidor Hapi escutando em localhost na porta especificada (por padrão 3000), com uma rota GET simples na raiz /.

Entrando no modo de desenvolvimento e configurando site no ServBay

Durante o desenvolvimento, rode seu app Node.js e use o recurso de proxy reverso do ServBay para mapear para um domínio personalizado acessível via navegador e SSL fornecido pelo ServBay.

1. Rodar o servidor Hapi.js em modo desenvolvimento

   No terminal, estando dentro da pasta servbay-hapi-app, rode o servidor em uma porta específica (ex: 8585):

   PORT=8585 node server.js

   O servidor iniciará e exibirá algo como Server running on http://localhost:8585. Mantenha esse terminal aberto.

2. Configurar o site no ServBay (proxy reverso)

   Abra o ServBay. Vá na aba "Sites" e clique no botão "+" no canto inferior esquerdo para adicionar um site novo.

   • Nome: ServBay Hapi Dev (ou qualquer nome para referência interna)
   • Domínio: servbay-hapi-dev.servbay.demo (recomendado usar o .servbay.demo para evitar conflitos e aproveitar o certificado CA local do ServBay)
   • Tipo: Proxy reverso (Reverse Proxy)
   • Proxy para:
     • Protocolo: http
     • Endereço IP: 127.0.0.1 (servidor Node.js rodando em localhost)
     • Porta: 8585 (deve corresponder à PORT usada ao rodar o server)

   Clique em "Adicionar". O ServBay irá automaticamente configurar o servidor web (Caddy ou Nginx) para redirecionar requisições de https://servbay-hapi-dev.servbay.demo para http://127.0.0.1:8585. O ServBay também irá criar e confiar no certificado SSL para o domínio .servbay.demo através do User CA, permitindo acesso local seguro via HTTPS.

   Para mais detalhes sobre configuração, consulte a documentação de sites do ServBay.

3. Acessar a aplicação Hapi.js em desenvolvimento

   No seu navegador, acesse https://servbay-hapi-dev.servbay.demo. Deverá aparecer "Hello from Hapi.js powered by ServBay!".

   Agora, qualquer alteração feita em server.js (especialmente usando ferramentas de auto-reload como nodemon) será refletida imediatamente no navegador via proxy reverso do ServBay.

Exemplo de Deploy para Produção

Para ambiente de produção, recomenda-se um gerenciamento de processos mais robusto (como PM2) e configurações separadas. Veja um exemplo básico, rodando em outra porta e acessível via ServBay:

1. Rodando o servidor Hapi.js em modo produção

   Usando uma porta diferente (ex: 8586) e variáveis de ambiente de produção:

   PORT=8586 NODE_ENV=production node server.js

   (Observação: Em produção recomenda-se gerenciar o processo com PM2 ou similar para garantir estabilidade e auto-restart. O ServBay suporta integração com o PM2.)

2. Configurar site de produção no ServBay (proxy reverso)

   No ServBay, aba "Sites", clique novamente em "+" e preencha:

   • Nome: ServBay Hapi Prod
   • Domínio: servbay-hapi-prod.servbay.demo
   • Tipo: Proxy reverso (Reverse Proxy)
   • Proxy para:
     • Protocolo: http
     • Endereço IP: 127.0.0.1
     • Porta: 8586

   Clique em "Adicionar".

3. Acessar o Hapi.js de produção

   No navegador, acesse https://servbay-hapi-prod.servbay.demo. Você verá a mesma resposta do modo de desenvolvimento (a menos que o código trate o NODE_ENV de alguma forma diferente), mas rodando com características de produção.

O recurso Sites do ServBay permite gerenciar múltiplos domínios locais para desenvolvimento ou simulação de produção, mapeando-os para diferentes instâncias Node.js rodando em portas separadas.

Conectando-se aos Bancos de Dados do ServBay

O ServBay traz suporte integrado a diversos bancos de dados, incluindo MySQL, MariaDB, PostgreSQL, MongoDB e Redis. Veja como conectar cada um deles usando Hapi.js.

Importante: Antes de tudo, habilite o pacote do banco desejado em "Pacotes" do ServBay e inicie o banco pelo painel de controle. Assim, verifique se o serviço do banco está rodando.

Os usuários e senhas padrão do ServBay:

• MySQL/MariaDB: Usuário root, senha password
• PostgreSQL: Usuário user, senha password
• MongoDB: Sem autenticação (padrão)
• Redis: Sem autenticação (padrão)

Atenção: Por segurança, recomenda-se alterar as senhas padrão dos bancos do ServBay, principalmente em ambientes não-locais. Você pode redefinir facilmente pela interface do ServBay; veja as instruções aqui.

A seguir, exemplos de código para conectar os bancos. Instale o cliente correspondente com npm antes do uso.

1. Conectando ao MySQL

   Instale o cliente:

   npm install mysql2 # ou mysql

   Exemplo de conexão (com mysql2):

   const mysql = require('mysql2');
   
   const connection = mysql.createConnection({
     host: 'localhost',
     user: 'root', // Usuário padrão do ServBay
     password: 'password', // Senha padrão do ServBay
     database: 'servbay_hapi_app' // Substitua pelo seu banco de dados
   });
   
   connection.connect(err => {
     if (err) {
       console.error('Error connecting to MySQL: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL as id ' + connection.threadId);
   });
   
   // Feche a conexão quando necessário
   // connection.end();

2. Conectando ao MariaDB

   Instale o cliente:

   npm install mariadb

   Exemplo de conexão:

   const mariadb = require('mariadb');
   const pool = mariadb.createPool({
     host: 'localhost',
     user: 'root', // Usuário padrão do ServBay
     password: 'password', // Senha padrão do ServBay
     database: 'servbay_hapi_app', // Substitua pelo seu banco
     connectionLimit: 5 // Tamanho do pool de conexões
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB");
       // conn.query(...) para executar consulta
       conn.release(); // Devolva a conexão ao pool
     })
     .catch(err => {
       console.error("Not connected to MariaDB due to error: " + err);
     });

3. Conectando ao PostgreSQL

   Instale o cliente:

   npm install pg

   Exemplo de conexão:

   const { Pool } = require('pg');
   const pool = new Pool({
     user: 'user', // Usuário padrão do ServBay
     host: 'localhost',
     database: 'servbay_hapi_app', // Substitua pelo seu banco
     password: 'password', // Senha padrão do ServBay
     port: 5432, // Porta padrão PostgreSQL
   });
   
   pool.connect((err, client, done) => {
     if (err) {
       console.error('Error connecting to PostgreSQL: ', err);
       return;
     }
     console.log('Connected to PostgreSQL');
     client.query('SELECT NOW()', (err, res) => {
       done(); // Libera a conexão
       if (err) {
         console.error('Error executing query', err.stack);
       } else {
         console.log('PostgreSQL current time:', res.rows[0].now);
       }
     });
   });
   
   // O pool é fechado automaticamente ao sair do app
   // pool.end();

4. Conectando ao MongoDB

   Instale o cliente:

   npm install mongoose # ou mongodb

   Exemplo de conexão (usando mongoose):

   const mongoose = require('mongoose');
   
   mongoose.connect('mongodb://localhost/servbay-hapi-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     // MongoDB padrão do ServBay não requer autenticação.
     // Caso ative autenticação, configure authSource, user e pass:
     // authSource: 'admin',
     // user: 'seu_usuario',
     // pass: 'sua_senha',
   })
   .then(() => console.log('MongoDB connected'))
   .catch(err => console.error('MongoDB connection error:', err));
   
   // A conexão do Mongoose fica ativa durante toda a aplicação
   // Para desconectar: mongoose.connection.close();

5. Conectando ao Redis

   Instale o cliente:

   npm install redis

   Exemplo de conexão:

   const redis = require('redis');
   // Usa parâmetros padrões: host 'localhost', porta 6379
   const client = redis.createClient();
   
   client.on('error', function (err) {
     console.error('Redis Error: ' + err);
   });
   
   client.on('connect', function () {
     console.log('Redis client connected');
   });
   
   // Conecta ao servidor Redis
   client.connect(); // Para redis v4+, é necessário chamar connect()
   
   // Exemplo: set/get de chave
   // async function exampleRedisUsage() {
   //   await client.set('mykey', 'myvalue');
   //   const value = await client.get('mykey');
   //   console.log('Value from Redis:', value);
   //   await client.del('mykey');
   // }
   // exampleRedisUsage();
   
   // Feche a conexão ao sair do app
   // client.quit();

Integrando esses códigos ao seu app Hapi.js, você poderá usar todos os bancos que o ServBay oferece para desenvolvimento local.

Conclusão

Com o ServBay, montar um ambiente Hapi.js no macOS fica muito mais eficiente. Ele oferece uma solução completa com Node.js fácil de instalar e gerenciar, bancos de dados prontos para uso e recursos de Sites (proxy reverso e SSL automático), simplificando ao máximo o acesso local seguro. Siga este passo a passo para iniciar rapidamente seu projeto Hapi.js e aproveite todo o potencial do ServBay para acelerar seu fluxo de desenvolvimento.