¡Desarrollo backend Node.js eficiente con paquetes NPM esenciales! 🚀

Express (Marco de aplicaciones web)

Express es un framework de aplicaciones web rápido y minimalista para Node.js, que simplifica la gestión de rutas, peticiones y respuestas.

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello, Express!');
});

app.listen(3000, () => {
  console.log('Server is running on <http://localhost:3000>');
});

Mongoose (ODM de MongoDB)

Mongoose actúa como Object-Document Mapper, tendiendo un puente entre Node.js y MongoDB, permitiendo la validación de esquemas y la construcción de consultas.

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/myapp', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const userSchema = new mongoose.Schema({
  username: String,
  email: String,
  password: String
});

const User = mongoose.model('User', userSchema);

bcrypt (Password Hashing)

bcrypt proporciona un hash de contraseñas seguro, protegiendo las contraseñas de los usuarios convirtiéndolas en códigos hash irreversibles.

const bcrypt = require('bcrypt');

const plaintextPassword = 'secretPassword';

bcrypt.hash(plaintextPassword, 10, (err, hash) => {
  if (err) throw err;
  console.log('Hashed Password:', hash);
  bcrypt.compare(plaintextPassword, hash, (err, result) => {
    if (err) throw err;
    console.log('Password Correct:', result); // true
  });
});

JWT (JSON Web Tokens)

jsonwebtoken permite crear, firmar y verificar JSON Web Tokens para la comunicación segura cliente-servidor y la autenticación de usuarios.

Recuerda que si tu quieres aprender acerca de JWT puedes hacerlo en el siguiente video

const jwt = require('jsonwebtoken');

const payload = { userId: 12345 };
const secretKey = 'mySecretKey';
const token = jwt.sign(payload, secretKey, { expiresIn: '1h' });

console.log('Token:', token);

jwt.verify(token, secretKey, (err, decoded) => {
  if (err) throw err;
  console.log('Token Content:', decoded);
});

Async (Operaciones asíncronas)

Async proporciona funciones de utilidad para manejar tareas asíncronas y gestionar flujos asíncronos con facilidad.

const async = require('async');

async.parallel([
  function(callback) {
    setTimeout(function() {
      console.log('Task 1 Completed');
      callback(null, '1');
    }, 200);
  },
  function(callback) {
    setTimeout(function() {
      console.log('Task 2 Completed');
      callback(null, '2');
    }, 100);
  }
], function(err, results) {
  console.log('Results:', results); // ['1', '2']
});

Morgan (Registrador de peticiones HTTP)

Morgan es un middleware de registro de peticiones para aplicaciones Express, que proporciona información detallada sobre las peticiones entrantes.

const express = require('express');
const morgan = require('morgan');
const app = express();

app.use(morgan('dev'));
app.get('/', (req, res) => {
  res.send('Hello, Express!');
});
app.listen(3000, () => {
  console.log('Server is running on <http://localhost:3000>');
});

Dotenv (Variables de entorno)

Dotenv permite gestionar variables de entorno en aplicaciones Node.js, manteniendo los datos sensibles seguros en un archivo '.env' separado.

require('dotenv').config();

const apiKey = process.env.API_KEY;
console.log('API Key:', apiKey);

Passport (Middleware de autenticación)

Passport es un middleware de autenticación versátil que admite varias estrategias de autenticación, garantizando una autenticación segura en tu aplicación.

const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;

passport.use(new LocalStrategy(
  function(username, password, done) {
    // User authentication logic here
    if (username === 'admin' && password === 'adminpass') {
      return done(null, { username: 'admin' });
    } else {
      return done(null, false);
    }
  }
));

Stripe (Procesamiento de pagos)

Stripe facilita el procesamiento de pagos en aplicaciones Node.js, permitiendo transacciones y gestión de pagos sin problemas.

const stripe = require('stripe')('sk_test_XXX'); // Stripe Secret Key

stripe.charges.create({
  amount: 1000,
  currency: 'usd',
  source: 'tok_visa', // Test card token
  description: 'Sample Payment'
}).then(charge => {
  console.log('Payment Successful:', charge);
}).catch(err => {
  console.error('Payment Error:', err);
});

Nodemon (Vigilante del servidor de desarrollo)

Nodemon automatiza los reinicios del servidor cada vez que se detectan cambios en el código, lo que mejora el flujo de trabajo de desarrollo.

Instala: npm install --save-dev nodemon

Nodemailer (Envío de correo electrónico)

Nodemailer simplifica el envío de correos electrónicos desde aplicaciones Node.js y soporta varios proveedores de correo electrónico.

const nodemailer = require('nodemailer');

const transporter = nodemailer.createTransport({
  service: 'gmail',
  auth: {
    user: 'user@gmail.com',
    pass: 'password'
  }
});
const mailOptions = {
  from: 'user@gmail.com',
  to: 'recipient@gmail.com',
  subject: 'Hello',
  text: 'This is a test email.'
};
transporter.sendMail(mailOptions, (error, info) => {
  if (error) {
    console.log('Email Sending Error:', error);
  } else {
    console.log('Email Sent:', info.response);
  }
});

Cloudinary (Gestión de medios)

Cloudinary simplifica la gestión de imágenes y vídeos proporcionando soluciones basadas en la nube para su almacenamiento y manipulación.

const cloudinary = require('cloudinary').v2;

cloudinary.config({
  cloud_name: 'your_cloud_name',
  api_key: 'your_api_key',
  api_secret: 'your_api_secret'
});
cloudinary.uploader.upload('my_image.jpg', (error, result) => {
  if (error) {
    console.log('Error:', error);
  } else {
    console.log('Image URL:', result.secure_url);
  }
});

Axios (Cliente HTTP)

Axios es un popular cliente HTTP para Node.js, que realiza peticiones API a servicios externos y gestiona las respuestas.

const axios = require('axios');

axios.get('<https://jsonplaceholder.typicode.com/posts/1>')
  .then(response => {
    console.log('Title:', response.data.title);
  })
  .catch(error => {
    console.log('Error:', error);
  });

Randomstring (Generación de cadenas aleatorias)

Randomstring ayuda a generar cadenas aleatorias, que pueden ser útiles para varios propósitos.

const randomstring = require('randomstring');

const randomString = randomstring.generate(10);
console.log('Random String:', randomString);

EJS (Embedded JavaScript Templating)

EJS es un motor de plantillas para renderizar contenidos dinámicos en el lado del servidor, mejorando el desarrollo de páginas web dinámicas.

const express = require('express');
const app = express();

app.set('view engine', 'ejs');

app.get('/', (req, res) => {
  const data = { message: 'Hello, EJS!' };
  res.render('index', data);
});

app.listen(3000, () => {
  console.log('Server is running on <http://localhost:3000>');
});

Joi (Data Validation)

Joi es un potente paquete para la validación de datos en aplicaciones Node.js, mejorando la seguridad y fiabilidad.

const Joi = require('joi');

const schema = Joi.object({
  username: Joi.string()
    .alphanum()
    .min(3)
    .max(30)
    .required(),

  email: Joi.string()
    .email({ minDomainSegments: 2, tlds: { allow: ['com', 'net'] } })
    .required(),

  password: Joi.string()
    .pattern(new RegExp('^[a-zA-Z0-9]{3,30}$'))
    .required()
});

const data = {
  username: 'JohnDoe',
  email: 'johndoe@example.com',
  password: 'myp@ssw0rd'
};

const result = schema.validate(data);
console.log(result);

Fuente