Configuración del entorno de desarrollo Hapi.js con ServBay

Hapi.js es un potente y flexible framework para Node.js, ideal para construir aplicaciones y APIs. ServBay ofrece a los desarrolladores de Node.js un entorno de desarrollo local conveniente, con integración del runtime de Node.js, múltiples sistemas de bases de datos y un servidor web fácil de configurar. En este artículo aprenderás cómo crear y ejecutar proyectos Hapi.js en el entorno de ServBay, configurar el acceso mediante la función de Sitios Web (Websites) de ServBay y conectar con las bases de datos integradas de ServBay.

¿Qué es Hapi.js?

Hapi.js es un framework robusto y flexible para Node.js, desarrollado por Walmart Labs, diseñado para construir aplicaciones y servicios. Se destaca por su sistema de plugins, su enfoque basado en configuración y sus características de seguridad integradas, facilitando a los desarrolladores la creación de aplicaciones web y APIs eficientes y mantenibles.

Principales características y ventajas de Hapi.js

• Sistema de plugins: Hapi.js cuenta con un sistema de plugins potente y sencillo de usar, permitiendo ampliar la funcionalidad del framework o modularizar la lógica en componentes reutilizables.
• Enfoque basado en configuración: Hapi.js apuesta por un desarrollo impulsado por configuración, definiendo rutas, validaciones, cacheo y otros comportamientos mediante opciones detalladas.
• Validación de entrada: Integra la librería Joi, ofreciendo validación declarativa de datos para garantizar la integridad y seguridad de la información procesada.
• Ecosistema rico: Dispone de una comunidad activa y una amplia gama de plugins oficiales y de terceros, cubriendo necesidades habituales como autenticación, autorización, registro, cacheo y más.
• Seguridad: Incluye medidas de seguridad integradas para ayudar a prevenir amenazas comunes en aplicaciones web, como validación de entrada y control de CORS.
• Logging y depuración: Ofrece detallados logs del ciclo de vida de las peticiones y herramientas de depuración.

Con Hapi.js, puedes concentrarte en la lógica de negocio mientras dejas el manejo de HTTP, enrutamiento, validaciones y seguridad al framework.

Configuración de un proyecto Hapi.js usando ServBay

En esta sección te mostraremos cómo crear y ejecutar un proyecto básico de Hapi.js en el entorno Node.js de ServBay y cómo exponerlo usando la función de Sitios Web (proxy inverso) de ServBay.

Requisitos previos

Antes de comenzar, asegúrate de que:

1. ServBay esté instalado correctamente en tu macOS.
2. Tienes habilitado el paquete de Node.js en la pestaña "Paquetes" de ServBay. Puedes encontrar y activar Node.js desde el panel de control de ServBay.
3. Estás familiarizado con el uso básico de la terminal y el gestor de paquetes npm de Node.js.

Crear un proyecto Hapi.js

1. Inicializa el directorio del proyecto

   Abre la terminal y navega al directorio raíz recomendado de ServBay para sitios web: /Applications/ServBay/www. Crea una nueva carpeta para tu proyecto (por ejemplo, servbay-hapi-app) y accede a ella:

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

2. Inicializa el proyecto Node.js

   Dentro del directorio, usa npm para inicializar un nuevo proyecto de Node.js:

   npm init -y

   Esto creará un archivo package.json en la raíz de tu proyecto.

3. Instala la dependencia de Hapi.js

   Usa npm para instalar la librería principal de Hapi.js:

   npm install @hapi/hapi

   Así añadirás @hapi/hapi a las dependencias de tu proyecto.

4. Crea el archivo principal de tu aplicación

   En la raíz del proyecto, crea un archivo llamado server.js y añade el siguiente código para iniciar un servidor Hapi.js básico:

   'use strict'; // Habilita el modo estricto
   
   const Hapi = require('@hapi/hapi');
   
   const init = async () => {
   
     const server = Hapi.server({
       port: process.env.PORT || 3000, // Por defecto escucha en el puerto 3000 o utiliza el indicado por la variable de entorno PORT
       host: 'localhost' // Escucha en la dirección de loopback local
     });
   
     // Define una ruta raíz sencilla
     server.route({
       method: 'GET',
       path: '/',
       handler: (request, h) => {
         return 'Hello from Hapi.js powered by ServBay!';
       }
     });
   
     // Inicia el servidor
     await server.start();
     console.log('Server running on %s', server.info.uri);
   };
   
   // Maneja errores no capturados de promesas rechazadas
   process.on('unhandledRejection', (err) => {
     console.error(err);
     process.exit(1); // Sale del proceso
   });
   
   // Llama a la función init para arrancar la aplicación
   init();

   Este script inicia un servidor Hapi que escucha en localhost en el puerto especificado (por defecto 3000), y define un handler GET sencillo para la ruta /.

Modo desarrollo y configuración de sitio web en ServBay

Durante el desarrollo, puedes ejecutar la app de Node.js y hacerla accesible a través del proxy inverso de ServBay usando un dominio personalizado, y también aprovechar los certificados SSL ofrecidos por ServBay.

1. Ejecuta el servidor de desarrollo Hapi.js

   En la terminal, asegúrate de estar en el directorio de tu proyecto servbay-hapi-app y ejecuta el archivo server.js usando Node, seleccionando un puerto específico —por ejemplo, el 8585— que coincidirá con la configuración de proxy inverso:

   PORT=8585 node server.js

   El servidor arrancará y mostrará la URI en la que está escuchando, por ejemplo: Server running on http://localhost:8585. Mantén esta ventana abierta para que el servidor continúe corriendo.

2. Configura el sitio web (proxy inverso) en ServBay

   Abre la aplicación ServBay. Ve a la pestaña "Sitios Web" y haz clic en el botón "+" en la esquina inferior izquierda para añadir un nuevo sitio.

   • Nombre (Name): ServBay Hapi Dev (puedes personalizarlo para identificarlo en ServBay)
   • Dominio (Domain): servbay-hapi-dev.servbay.demo (se recomienda usar la terminación .servbay.demo para evitar conflictos con dominios reales y aprovechar el CA local de ServBay)
   • Tipo de sitio (Type): Selecciona Proxy inverso (Reverse Proxy)
   • Proxy hacia (Proxy to):
     • Protocolo (Protocol): http
     • Dirección IP (IP Address): 127.0.0.1 (el servidor Node.js estará corriendo en loopback)
     • Puerto (Port): 8585 (debe coincidir con el valor usado en PORT al ejecutar el script)

   Haz clic en "Añadir" para guardar la configuración. ServBay configurará automáticamente el servidor web (como Caddy o Nginx) para que el dominio https://servbay-hapi-dev.servbay.demo haga de proxy inverso hacia http://127.0.0.1:8585, generando y confiando automáticamente en los certificados SSL para .servbay.demo (mediante ServBay User CA).

   Para una guía detallada de configuración, consulta la documentación sobre sitios web en ServBay.

3. Accede a tu aplicación Hapi.js de desarrollo

   Abre tu navegador y accede al dominio que configuraste: https://servbay-hapi-dev.servbay.demo. Deberías ver el mensaje "Hello from Hapi.js powered by ServBay!".

   Cualquier cambio que realices en server.js (especialmente si usas herramientas como nodemon para recarga automática) se reflejará al instante en tu navegador a través del proxy de ServBay.

Despliegue del entorno de producción (Ejemplo)

Para entornos productivos, se recomienda usar un manejador de procesos (como PM2) y una configuración adaptada. Aquí tienes un ejemplo rápido para ejecutarlo en otro puerto y exponerlo mediante proxy inverso:

1. Ejecuta el servidor de producción Hapi.js

   Por ejemplo, usando el puerto 8586 y el entorno de producción:

   PORT=8586 NODE_ENV=production node server.js

   (Nota: En un entorno real de producción, deberías usar PM2 u otro gestor para asegurar estabilidad y reinicio automático. ServBay puede integrarse con PM2.)

2. Configura el sitio web de producción (proxy inverso) en ServBay

   En la pestaña "Sitios Web" en ServBay, haz clic nuevamente en "+" para añadir un sitio:

   • Nombre (Name): ServBay Hapi Prod
   • Dominio (Domain): servbay-hapi-prod.servbay.demo
   • Tipo de sitio (Type): Proxy inverso (Reverse Proxy)
   • Proxy hacia (Proxy to):
     • Protocolo (Protocol): http
     • Dirección IP (IP Address): 127.0.0.1
     • Puerto (Port): 8586

   Haz clic en "Añadir".

3. Accede a la versión de producción de tu app Hapi.js

   Ve a https://servbay-hapi-prod.servbay.demo en tu navegador. El resultado será igual al modo desarrollo (salvo que tu código cambie en función de NODE_ENV), pero estará corriendo bajo una simulación de entorno productivo.

Gracias a la función de Sitios Web de ServBay, puedes gestionar cómodamente varios dominios locales, tanto para desarrollo como para pruebas de producción, y dirigirlos fácilmente hacia diferentes instancias de tus aplicaciones Node.js/Hapi.js.

Conexión con las bases de datos que ofrece ServBay

ServBay incluye y soporta por defecto diferentes sistemas de bases de datos como MySQL, MariaDB, PostgreSQL, MongoDB y Redis. A continuación te mostramos cómo conectar cada una desde tu proyecto Hapi.js.

Importante: Antes de intentar conectar a una base de datos, asegúrate de haber activado desde la pestaña "Paquetes" los servicios que vayas a usar y que las bases de datos estén ejecutándose (puedes comprobarlo en el panel principal de ServBay).

Usuarios y contraseñas por defecto en ServBay:

• MySQL/MariaDB: usuario root, contraseña password
• PostgreSQL: usuario user, contraseña password
• MongoDB: Sin autenticación por defecto
• Redis: Sin autenticación por defecto

Nota: Por seguridad, es altamente recomendable cambiar las contraseñas por defecto desde ServBay, especialmente si piensas usar los servicios fuera del entorno local. Puedes resetear la contraseña de root de MySQL, MariaDB o PostgreSQL fácilmente desde el panel. Ver más en la documentación de reseteo de contraseñas.

A continuación tienes ejemplos de código para conectar a cada base de datos. Recuerda instalar el cliente correspondiente con npm antes de usarlos.

1. Conectar a MySQL

   Instala el cliente de MySQL:

   npm install mysql2 # o mysql

   Ejemplo de conexión usando mysql2:

   const mysql = require('mysql2');
   
   const connection = mysql.createConnection({
     host: 'localhost',
     user: 'root', // Usuario por defecto de ServBay
     password: 'password', // Contraseña por defecto de ServBay
     database: 'servbay_hapi_app' // Reemplaza con el nombre de tu base de datos
   });
   
   connection.connect(err => {
     if (err) {
       console.error('Error connecting to MySQL: ' + err.stack);
       return;
     }
     console.log('Connected to MySQL as id ' + connection.threadId);
   });
   
   // Cierra la conexión cuando no la necesites
   // connection.end();

2. Conectar a MariaDB

   Instala el cliente para MariaDB:

   npm install mariadb

   Ejemplo de conexión:

   const mariadb = require('mariadb');
   const pool = mariadb.createPool({
     host: 'localhost',
     user: 'root', // Usuario por defecto de ServBay
     password: 'password', // Contraseña por defecto de ServBay
     database: 'servbay_hapi_app', // Reemplaza con el nombre de tu base de datos
     connectionLimit: 5 // Tamaño del pool
   });
   
   pool.getConnection()
     .then(conn => {
       console.log("Connected to MariaDB");
       // conn.query(...) Ejecutar consultas
       conn.release(); // Devuelve la conexión al pool
     })
     .catch(err => {
       console.error("Not connected to MariaDB due to error: " + err);
     });

3. Conectar a PostgreSQL

   Instala el cliente de PostgreSQL:

   npm install pg

   Ejemplo de conexión:

   const { Pool } = require('pg');
   const pool = new Pool({
     user: 'user', // Usuario por defecto de ServBay
     host: 'localhost',
     database: 'servbay_hapi_app', // Reemplaza con el nombre de tu base de datos
     password: 'password', // Contraseña por defecto de ServBay
     port: 5432, // Puerto por defecto de 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 la conexión del cliente
       if (err) {
         console.error('Error executing query', err.stack);
       } else {
         console.log('PostgreSQL current time:', res.rows[0].now);
       }
     });
   });
   
   // El pool se cerrará automáticamente al cerrar la aplicación
   // pool.end();

4. Conectar a MongoDB

   Instala el cliente de MongoDB:

   npm install mongoose # o mongodb

   Ejemplo de conexión usando mongoose:

   const mongoose = require('mongoose');
   
   mongoose.connect('mongodb://localhost/servbay-hapi-app', {
     useNewUrlParser: true,
     useUnifiedTopology: true,
     // La instalación por defecto de MongoDB en ServBay no requiere autenticación. Si la configuras, añade authSource, user, pass.
     // authSource: 'admin',
     // user: 'your_username',
     // pass: 'your_password',
   })
   .then(() => console.log('MongoDB connected'))
   .catch(err => console.error('MongoDB connection error:', err));
   
   // La conexión de Mongoose se mantiene activa durante todo el ciclo de vida de la app
   // Para desconectarse: mongoose.connection.close();

5. Conectar a Redis

   Instala el cliente de Redis:

   npm install redis

   Ejemplo de conexión:

   const redis = require('redis');
   // Parámetros por defecto: host: 'localhost', port: 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 con el servidor Redis
   client.connect(); // En redis v4+ es necesario llamar a connect()
   
   // Ejemplo: Setear y obtener un valor
   // 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();
   
   // Cierra la conexión al salir
   // client.quit();

Integra estos fragmentos de conexión en tu app Hapi.js para aprovechar los servicios de base de datos que ServBay ofrece en tu entorno de desarrollo local.

Conclusión

Con ServBay, montar un entorno de desarrollo para Hapi.js en macOS es rápido y eficiente. ServBay ofrece una solución integral: fácil gestión e instalación del runtime de Node.js, múltiples bases de datos listas para usar y acceso local sencillo mediante el sistema de Sitios Web (con proxy inverso y SSL automático). Sigue estos pasos para poner en marcha tu proyecto Hapi.js y aprovecha toda la potencia de ServBay para acelerar tu flujo de desarrollo.