Node.js y Git: Control de Versiones

Git es un sistema de control de versiones distribuido, ampliamente utilizado en el desarrollo de software. Fue creado por Linus Torvalds en 2005 y, desde entonces, se ha convertido en una herramienta esencial tanto para proyectos de código abierto como para proyectos privados.

Mi experiencia previa con control de versiones

Antes de usar Git, trabajaba en proyectos de forma manual. Cada día, debía hacer una copia de seguridad del código original, nombrar la carpeta con la fecha, y luego pasarla a mi jefe, quien verificaba los cambios. Si todo estaba correcto, se añadían los cambios al código original. Este proceso manual era nuestra forma rudimentaria de control de versiones, pero era tedioso y propenso a errores.

Para instalar Git en Windows, sigue estos pasos:

Ve al sitio web oficial de Git: https://git-scm.com/

Descarga el instalador para tu versión de Windows. Asegúrate de descargar la versión correcta para tu sistema operativo (32 bits o 64 bits).
Ejecuta y sigue los pasos.
En la pantalla "Adjusting your PATH environment," selecciona la opción "Use Git from the Windows Command Prompt." Esto agrega Git al PATH de Windows para que puedas usarlo desde la línea de comandos.
En la pantalla "Choosing HTTPS transport backend," puedes seleccionar la opción "Use the OpenSSL library" para utilizar OpenSSL en lugar de la biblioteca de Windows para conexiones seguras.
Para verificar que la instalación fue exitosa, abre una ventana de comandos y escribe "git --version". Deberías ver la versión de Git que se ha instalado.

Para instalar en Linux. sigue estos pasos en terminal:

sudo apt update
sudo apt install git

Una vez instalado puede verificar en rerminal con:

git --version

Cómo funciona Git

Al iniciar un proyecto, también se inicia un repositorio Git. A medida que los desarrolladores realizan cambios en el código y están seguros de ellos, le dan a Git la orden de recopilar estos cambios. Esto se conoce como un commit, y cada commit lleva una descripción que explica qué se ha modificado.

Una de las funcionalidades más útiles de Git es la posibilidad de crear ramas. Las ramas permiten a los desarrolladores trabajar en nuevas funcionalidades o correcciones sin afectar la rama principal (normalmente llamada main o master). Una vez que los cambios han sido probados y validados, se puede fusionar la rama con la principal, asegurando que la versión estable no se vea afectada hasta que todo esté listo.

Ventajas de Git para el trabajo en equipo

Git facilita enormemente el trabajo en equipo. Varias personas pueden trabajar simultáneamente en diferentes ramas sin afectar el código principal. Esto asegura que las funcionalidades en desarrollo no interfieran con el código en producción. Además, Git mantiene un registro detallado de quién hizo qué cambios, lo que es útil para la revisión y auditoría del código.

Uso de Git: Gráfico y Comandos

Git se puede utilizar tanto a través de una interfaz gráfica como mediante línea de comandos. Según mi experiencia, es recomendable aprender primero los comandos básicos de Git, como git add, git commit, git push, y luego usar una interfaz gráfica si es necesario. Dominar los comandos proporciona una comprensión más profunda de cómo funciona Git, y la interfaz gráfica puede ser una herramienta complementaria útil.

Git no hace parte de la tecnologia MERN pero vamos a manejarlo ya que es una herramienta fundamental en control de versiones. Ahora vamos a la practica, ya tenemos un código del servidor básico que lo vamos abrir con visual studio y también abrir un terminal

Paso 1 iniciamos repositorio git init

En el explorador aparece de color verde y la vocal U, indicando que hay archivos nuevos para actualizar

Paso 2 Adicionamos todos los cambios con

git add .

Paso 3 Hacemos un commit "descripción del cambio" con

git commit -m "inicio servidor"

Y listo ya quedo el primer commit de muchos que se harán para un mejor control de nuestro código, el explorador ya aparece así.

Vamos adicionar unas lineas de código en app.js e index.js para control de errores cuando no se encuentra una ruta,error en el código o servidor.

Paso 4 En app.js agregamos

// Configuración de rutas y middlewares
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

app.use(express.json()) se utiliza para analizar solicitudes con contenido JSON y convertirlo en objetos JavaScript

app.use(express.urlencoded({ extended: false })) se utiliza para analizar datos enviados desde formularios HTML.

Paso 5 En index.js se agrega

Este código dice que no se encuentra la ruta

// Middleware para manejar errores 404 (Not Found)
app.use((req, res, next) => {
  const error = new Error('Not Found');
  error.status = 404;
  next(error);
});

Estas lineas establece el código de estado de la respuesta HTTP en el valor de

error (err.status) o 500 si no se proporciona ningún código de estado y se envía una respuesta en formato JSON al cliente

// Middleware de manejo de errores
app.use((err, req, res, next) => {
  res.status(err.status || 500);
  res.json({
    error: {
      status: err.status || 500,
      message: err.message || 'Internal Server Error',
    },
  });
});

Y así queda el archivo index.js

import app from "./app.js"
const port = 3000;

//http://localhost:3000
app.get("/",(req,res) =>{
  res.send('Hola Mundo');
});

//http://localhost:3000/ruta1
app.get("/ruta1", (req, res) => {
  res.send('¡Hola desde otra ruta!');
});

// Ruta con parámetros , http://localhost:3000/usuario/Juan
app.get("/usuario/:id", (req, res) => {
  const userId = req.params.id;
  res.send(`Hola, usuario ${userId}!`);
});

// Middleware para manejar errores 404 (Not Found)
app.use((req, res, next) => {
  const error = new Error('Not Found');
  error.status = 404;
  next(error);
}); 

// Middleware de manejo de errores
app.use((err, req, res, next) => {
  res.status(err.status || 500);
  res.json({
    error: {
      status: err.status || 500,
      message: err.message || 'Internal Server Error',
    },
  });
});

// Iniciar el servidor y escuchar en el puerto especificado
app.listen(port, () => {
    console.log(`Conectado en el puerto:${port}`);
  });

Y así se ve en el explorador

Como se puede ver aparece una M y de otro color en app.js e index.js, quiere decir que se han hechos cambios y no se ha hecho commit.

Paso 6 Vamos a ejecutar el bakend

npm run dev

Resultado
http://localhost:3000 : Hola Mundo

http://localhost:3000/ruta1 : ¡Hola desde otra ruta!

http://localhost:3000/usuario/Juan : Hola, usuario Juan!

Y si colocamos otra ruta diferente

http://localhost:3000/ruta2 : {"error":{"status":404,"message":"Not Found"}}

Paso 7 Vamos a personalizar mejor el mensaje Not Found

// Middleware para manejar errores 404 (Not Found)

app.use((req, res, next) => {
  const error = new Error(`La ruta '${req.originalUrl}' 
                   no fue encontrada en el servidor.`);
  error.status = 404;
  next(error);
});

Aquí se utiliza req.originalUrl donde vamos a detectar lo que se escribió en la la barra de direcciones del navegador

http://localhost:3000/ruta2 :{"error":{"status":404,"message":"La ruta '/ruta2' no fue encontrada en el servidor."}}

Paso 8 Solo nos queda hacer el commit asi:

git add .

git commit -m "se agrega control de errores"

Con git log podemos observar detalles de los dos commits que se tiene.

Conclusión

Git es una herramienta indispensable para el desarrollo de software moderno. Facilita el trabajo en equipo, permite gestionar el historial de cambios de manera eficiente y ofrece flexibilidad para trabajar con ramas. Dominar Git, especialmente a través de comandos, te proporcionará una ventaja significativa en el desarrollo colaborativo.

Si aún no estás usando Git, es el momento de dar el salto. ¡Simplificará tu trabajo y el de tu equipo!

Ya implementado el git en el proyecto y agregando mas código control de errores. continuamos ahora si con mejorar estructura backend y conexión a mongodb en la próxima entrega.

Trabajando con MERN

Buscar este blog