Crear y ejecutar un proyecto NestJS localmente en macOS usando ServBay

NestJS es un framework progresivo para Node.js diseñado para construir aplicaciones del lado del servidor eficientes y escalables. Escrito en TypeScript e inspirado en Angular, NestJS adopta una arquitectura modular y un patrón de inyección de dependencias (DI). Ofrece potentes herramientas y funcionalidades para que los desarrolladores creen aplicaciones complejas que sean altamente mantenibles, testables y desacopladas.

Principales características y ventajas de NestJS

• Arquitectura modular: Organiza el código mediante módulos, facilitando la estructura, comprensión y mantenimiento de la aplicación.
• Inyección de dependencias: Ofrece un sistema de DI potente y fácil de usar, lo que mejora significativamente la testabilidad y mantenibilidad del código.
• Basado en TypeScript: Aprovecha la comprobación de tipos estáticos de TypeScript, interfaces y las características más modernas de JavaScript, optimizando la calidad y eficiencia del desarrollo al reducir errores en tiempo de ejecución.
• Decoradores extensos: Utiliza decoradores para definir controladores, servicios, módulos y otros artefactos, logrando un código más limpio, declarativo y expresivo.
• Ecosistema robusto: NestJS tiene una comunidad activa y abundancia de módulos y plugins de terceros, facilitando la integración con herramientas comunes como TypeORM, Mongoose, GraphQL, WebSockets, caché, validaciones y más.
• Basado en estándares: Construido sobre frameworks HTTP maduros como Express o Fastify, asegurando compatibilidad y un alto rendimiento.

Con NestJS, los desarrolladores pueden aplicar buenas prácticas de desarrollo backend (como los principios SOLID y patrones de diseño) para crear rápidamente aplicaciones web, APIs y microservicios empresariales de alto rendimiento.

Crear y ejecutar un proyecto NestJS con ServBay

ServBay ofrece un entorno de desarrollo web local potente e integrado para macOS, que incluye varias versiones de Node.js junto con bases de datos y servidores web populares. En esta guía, utilizaremos el entorno de Node.js y la función de 'Sitios web' de ServBay para crear, ejecutar y configurar un proyecto NestJS. Aprovechando el proxy inverso de ServBay, tu aplicación NestJS local podrá accederse mediante un dominio personalizado.

Requisitos previos

Antes de comenzar, asegúrate de que ya cuentas con lo siguiente:

1. Installer ServBay: ServBay ya está instalado correctamente en tu macOS.
2. Activar el paquete de Node.js: Desde la pestaña 'Paquetes' en el panel de control de ServBay, selecciona e instala la versión de Node.js que necesites. Si aún no has habilitado Node.js, revisa la Guía de uso de Node.js en ServBay para configurarlo.

Creación del proyecto NestJS

1. Instalar NestJS CLI globalmente

   Abre la terminal y utiliza npm (incluido comúnmente con Node.js) para instalar la herramienta CLI de NestJS de forma global. NestJS CLI facilita la inicialización, desarrollo y mantenimiento de aplicaciones NestJS.

   npm install -g @nestjs/cli

2. Inicializar el proyecto

   Cambia al directorio raíz sugerido para sitios web de ServBay: /Applications/ServBay/www. Este directorio es el lugar por defecto donde ServBay almacena sitios web, lo que facilita la configuración posterior. Luego, usa NestJS CLI para crear un nuevo proyecto:

   cd /Applications/ServBay/www
   nest new servbay-nest-app

   Tras ejecutar este comando, el CLI de NestJS te guiará por el proceso de creación, incluyendo la selección del gestor de paquetes (npm, yarn o pnpm). Se recomienda npm para mayor coherencia. El proyecto se generará dentro de /Applications/ServBay/www/servbay-nest-app.

3. Instalar dependencias del proyecto

   Accede al nuevo directorio del proyecto servbay-nest-app e instala las dependencias requeridas:

   cd servbay-nest-app
   npm install

   El comando nest new ejecuta automáticamente npm install, pero puedes volver a ejecutarlo para asegurar que todas las dependencias estén correctamente instaladas y actualizadas.

Modificar la respuesta por defecto de NestJS (opcional)

Para verificar que el proyecto funciona y es accesible vía ServBay, puedes modificar la respuesta predeterminada de la ruta raíz del proyecto.

1. Editar el archivo src/app.controller.ts

   Abre el archivo src/app.controller.ts en tu editor favorito y reemplázalo con el siguiente contenido para que la ruta '/' devuelva el mensaje "Hello ServBay!":

   import { Controller, Get } from '@nestjs/common';
   import { AppService } from './app.service'; // Asumiendo que mantienes AppService
   
   @Controller()
   export class AppController {
     constructor(private readonly appService: AppService) {} // Si conservas AppService
   
     @Get()
     getHello(): string {
       // return this.appService.getHello(); // Si usas AppService
       return 'Hello ServBay!'; // Devuelve directamente un string
     }
   }

   Este código define un controlador sencillo que gestiona solicitudes HTTP GET a la ruta raíz (/) devolviendo el string especificado.

Ejecutar NestJS en modo desarrollo y acceder mediante ServBay

Un proyecto NestJS se ejecuta normalmente en modo desarrollo utilizando el servidor integrado y escuchando en un puerto determinado. Luego, con la función de 'Sitios web' de ServBay puedes configurar un proxy inverso que apunte tu dominio personalizado al puerto de tu aplicación NestJS.

1. Iniciar el servidor de desarrollo

   Dentro del directorio /Applications/ServBay/www/servbay-nest-app, ejecuta el siguiente comando para levantar el servidor de desarrollo de NestJS. Puedes especificar el puerto configurando la variable de entorno PORT, por ejemplo 8585.

   cd /Applications/ServBay/www/servbay-nest-app
   PORT=8585 npm run start:dev

   El script npm run start:dev es parte de un proyecto NestJS estándar, ejecutando el código TypeScript con ts-node y activando el autorecargado por cambios. El servidor quedará en escucha en localhost:8585.

2. Configurar el proxy inverso en ServBay

   Abre el panel de control de ServBay y ve a la pestaña 'Sitios web'. Haz clic en el botón para añadir un nuevo sitio web (normalmente un +) y configura lo siguiente:

   • Nombre (Name): Ponle un nombre identificativo, como My first NestJS dev site.
   • Dominios (Domains): Ingresa el dominio local que deseas usar, por ejemplo servbay-nest-test.dev. ServBay resuelve por defecto dominios como .dev localmente, sin necesidad de editar el archivo hosts.
   • Tipo (Type): Selecciona Proxy inverso (Reverse Proxy).
   • Dirección IP (IP Address): Introduce la IP local en la que escucha Node.js, usualmente 127.0.0.1.
   • Puerto (Port): Escribe el puerto donde tu app NestJS escucha, en este caso 8585.

   Guarda la configuración. ServBay actualizará automáticamente la configuración en su servidor web (Caddy o Nginx). Para detalles, consulta la documentación sobre añadir sitios en ServBay.

3. Acceder al sitio web de desarrollo

   Abre tu navegador y visita el dominio configurado: https://servbay-nest-test.dev.

   Nota:

   • ServBay provee certificados SSL gratuitos (firmados por ServBay User CA) para tus sitios locales, permitiendo el acceso seguro vía https. Si ves advertencias de certificado, quizás debas confiar manualmente la CA de ServBay User. Consulta la documentación sobre seguridad SSL para más información.
   • Asegúrate de que el servidor de desarrollo de NestJS (PORT=8585 npm run start:dev) esté corriendo; si se detiene, el acceso al dominio fallará.

Desplegar una versión de producción y acceder mediante ServBay

Antes de poner tu aplicación NestJS en producción (incluso si es en local para pruebas), normalmente necesitas compilar el proyecto.

1. Construir la versión de producción

   Dentro de /Applications/ServBay/www/servbay-nest-app, ejecuta:

   cd /Applications/ServBay/www/servbay-nest-app
   npm run build

   El comando compilador generará el código JavaScript en el directorio dist.

2. Ejecutar el servidor en producción

   Una vez compilado, inicia el servidor NestJS en versión de producción. Utiliza node para correr el archivo compilado, por ejemplo en el puerto 8586 y configurando la variable de entorno NODE_ENV=production.

   cd /Applications/ServBay/www/servbay-nest-app
   PORT=8586 NODE_ENV=production node dist/main.js

   La versión de producción normalmente estática sin recarga automática.

3. Configurar el proxy inverso en ServBay para producción

   Regresa a la pestaña 'Sitios web' en ServBay para crear o modificar la configuración de acceso a producción:

   • Nombre (Name): Por ejemplo, My first NestJS production site.
   • Dominios (Domains): Por ejemplo, servbay-nest-test.prod.
   • Tipo (Type): Proxy inverso (Reverse Proxy).
   • Dirección IP (IP Address): 127.0.0.1.
   • Puerto (Port): 8586 (el puerto donde el servidor escucha).

   Guarda la configuración.

4. Acceder al sitio web en modo producción

   Visita https://servbay-nest-test.prod en tu navegador para ver tu aplicación NestJS en modo de producción. Nuevamente, ServBay ofrecerá cifrado SSL.

Conectar con bases de datos integradas en ServBay

ServBay incluye soporte para diversos sistemas de bases de datos como MariaDB (compatible con MySQL), PostgreSQL, MongoDB y Redis. Mientras desarrollas tu app NestJS, puedes conectar y usar estas bases de datos fácilmente.

Aviso importante: Antes de conectar, asegúrate de haber activado el paquete de base de datos correspondiente en la pestaña 'Paquetes' del panel de control de ServBay. Puedes consultar los puertos, usuarios y contraseñas por defecto en el propio panel o en la documentación de ServBay. En entornos de producción, es muy recomendable cambiar las credenciales por defecto y crear usuarios específicos con permisos mínimos.

A continuación, algunos ejemplos de configuración para conectar tu app NestJS, normalmente en el AppModule o módulos específicos de base de datos:

1. Conexión a MongoDB

   Utiliza el paquete @nestjs/mongoose para conectarte a MongoDB. Instálalo primero:

   npm install @nestjs/mongoose mongoose

   Luego, configura el MongooseModule en tu módulo NestJS:

   import { Module } from '@nestjs/common';
   import { MongooseModule } from '@nestjs/mongoose';
   // ... otros imports
   
   @Module({
     imports: [
       MongooseModule.forRoot('mongodb://localhost:27017/servbay-nest-app'), // Puerto por defecto 27017
       // ... otros módulos
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   La cadena de conexión suele ser mongodb://localhost:27017/ en ServBay. Usa herramientas como MongoDB Compass o mongosh para crear la base de datos servbay-nest-app.

2. Conexión a Redis

   Utiliza el módulo @nestjs/redis para conectar con Redis. Instala los paquetes necesarios:

   npm install @nestjs/redis redis @types/redis

   Configura el RedisModule:

   import { Module } from '@nestjs/common';
   import { RedisModule } from '@nestjs/redis';
   // ... otros imports
   
   @Module({
     imports: [
       RedisModule.forRoot({
         url: 'redis://localhost:6379', // Puerto por defecto 6379
       }),
       // ... otros módulos
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   Por defecto, el servidor Redis de ServBay está en localhost:6379.

3. Conexión a MariaDB (compatible con MySQL)

   Usa @nestjs/typeorm para conectar con MariaDB. ServBay soporta tanto MariaDB como MySQL; ambos son compatibles. Puedes usar los tipos mysql o mariadb en TypeORM. Instala primero los paquetes necesarios:

   npm install @nestjs/typeorm mysql2 typeorm

   Configura el TypeOrmModule:

   import { Module } from '@nestjs/common';
   import { TypeOrmModule } from '@nestjs/typeorm';
   // ... otros imports
   
   @Module({
     imports: [
       TypeOrmModule.forRoot({
         type: 'mariadb', // o 'mysql'
         host: 'localhost',
         port: 3306, // Puerto por defecto 3306
         username: 'root', // Usuario root por defecto en MariaDB/MySQL de ServBay
         password: 'password', // Contraseña root por defecto en MariaDB/MySQL de ServBay
         database: 'servbay_nest_app', // Debes crear primero la base de datos
         entities: [], // Tus entidades
         synchronize: true, // En desarrollo es útil, en producción úsalo con precaución
       }),
       // ... otros módulos
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   Nota: El usuario root y la contraseña password son los valores por defecto en MariaDB/MySQL de ServBay. Utiliza herramientas como TablePlus, DBeaver o MySQL CLI para conectarte a localhost:3306 y crea la base de datos servbay_nest_app. Por seguridad, cambia la contraseña del root y usa un usuario específico con permisos mínimos para tu app.

4. Conexión a PostgreSQL

   Usa @nestjs/typeorm para conectar con PostgreSQL. Instala los paquetes necesarios:

   npm install @nestjs/typeorm pg typeorm

   Configura el TypeOrmModule:

   import { Module } from '@nestjs/common';
   import { TypeOrmModule } from '@nestjs/typeorm';
   // ... otros imports
   
   @Module({
     imports: [
       TypeOrmModule.forRoot({
         type: 'postgres',
         host: 'localhost',
         port: 5432, // Puerto por defecto 5432
         username: 'servbay', // Usuario por defecto en PostgreSQL de ServBay (verifica según versión)
         password: 'password', // Contraseña por defecto (verifica en ServBay)
         database: 'servbay_nest_app', // Debes crear primero la base de datos
         entities: [], // Tus entidades
         synchronize: true, // Útil en desarrollo, en producción restringir
       }),
       // ... otros módulos
     ],
     controllers: [], // ...
     providers: [], // ...
   })
   export class AppModule {}

   Nota: Los usuarios y contraseñas por defecto pueden variar según la versión de PostgreSQL incluida en ServBay, habitualmente servbay o postgres como usuario. Revisa el panel o documentación de ServBay para confirmarlo y crea la base de datos y el usuario correspondiente usando un cliente PostgreSQL conectado a localhost:5432. Por seguridad, cambia las credenciales por defecto para producción.

Resumen

Con esta guía, has aprendido cómo crear, ejecutar y acceder rápidamente a proyectos NestJS en tu entorno local de macOS usando ServBay. El entorno integrado de Node.js, la sencilla configuración de sitios web (especialmente la función de proxy inverso) y el soporte para múltiples bases de datos incorporadas simplifican mucho el desarrollo y prueba local de aplicaciones NestJS. Puedes alternar fácilmente entre modos de desarrollo y producción, acceder de forma segura mediante dominios personalizados y HTTPS, y conectar tu aplicación a las potentes bases de datos que incluye ServBay.