En esta publicación, aprenderá cómo implementar notificaciones push usando JavaScript siguiendo las mejores prácticas de nivel de producción. Una de las mejores cosas es que también proporcionaré una estructura de carpetas para que puedas configurar tu proyecto fácilmente.

La configuración de notificaciones automáticas en una aplicación del mundo real requiere una planificación cuidadosa. Le mostraré cómo crear esta función en una aplicación Node.js profesional. Cubriremos partes importantes como cómo organizar tu código, mantener todo seguro y asegurarnos de que funcione bien incluso a medida que tu aplicación crece.

Para comenzar, necesita una biblioteca que le ayude a enviar notificaciones automáticas desde su servidor Node.js. La biblioteca web-push proporciona herramientas para enviar notificaciones y administrar las claves necesarias.

1. Notificación push: estructura del proyecto

Primero, configuremos la estructura del proyecto para mantener una base de código limpia y escalable:

/notification-service
├── /config
│   ├── default.js
│   └── production.js
├── /controllers
│   └── notificationController.js
├── /models
│   └── user.js
├── /routes
│   └── notificationRoutes.js
├── /services
│   ├── notificationService.js
│   ├── subscriptionService.js
│   └── webPushService.js
├── /utils
│   └── errorHandler.js
├── /tests
│   └── notification.test.js
├── app.js
├── package.json
├── .env
└── README.md

Paquetes NPM requeridos

Antes de profundizar en la implementación, asegúrese de tener instalados los siguientes paquetes de NPM:

• express: un marco de aplicación web Node.js mínimo y flexible.
• mongoose: una biblioteca ODM (Object Data Modeling) para MongoDB y Node.js.
• web-push: una biblioteca para enviar notificaciones push utilizando el protocolo Web Push.
• dotenv: un módulo de dependencia cero que carga variables de entorno desde un archivo .env.
• supertest: una biblioteca para probar aserciones HTTP en Node.js.

Instale estos paquetes usando npm:

bash

npm install express mongoose web-push dotenv supertest

2. Notificación push: configuración del proyecto

Crear archivos de configuración para diferentes entornos (por ejemplo, desarrollo, producción). Estos archivos almacenan configuraciones específicas del entorno.

// /config/default.js
module.exports = {
    server: {
        port: 3000,
        env: 'development'
    },
    pushNotifications: {
        publicVapidKey: process.env.VAPID_PUBLIC_KEY,
        privateVapidKey: process.env.VAPID_PRIVATE_KEY,
        gcmApiKey: process.env.GCM_API_KEY
    },
    db: {
        uri: process.env.MONGO_URI
    }
};

// /config/production.js
module.exports = {
    server: {
        port: process.env.PORT || 3000,
        env: 'production'
    },
    // Same structure as default, with production-specific values
};

3. Modelado de la base de datos

Utiliza Mongoose para definir tu esquema de usuario y suscripciones de notificaciones.

// /models/user.js
const mongoose = require('mongoose');

const subscriptionSchema = new mongoose.Schema({
    endpoint: String,
    keys: {
        p256dh: String,
        auth: String
    }
});

const userSchema = new mongoose.Schema({
    email: { type: String, required: true, unique: true },
    subscriptions: [subscriptionSchema],
    preferences: {
        pushNotifications: { type: Boolean, default: true }
    }
});

module.exports = mongoose.model('User', userSchema);

4. Servicios de notificación

Modularizar la lógica para manejar notificaciones en servicios.

// /services/webPushService.js
const webPush = require('web-push');
const config = require('config');

webPush.setVapidDetails(
    'mailto:[email protected]',
    config.get('pushNotifications.publicVapidKey'),
    config.get('pushNotifications.privateVapidKey')
);

module.exports = {
    sendNotification: async (subscription, payload) => {
        try {
            await webPush.sendNotification(subscription, JSON.stringify(payload));
        } catch (error) {
            console.error('Error sending notification', error);
        }
    }
};

// /services/notificationService.js
const User = require('../models/user');
const webPushService = require('./webPushService');

module.exports = {
    sendPushNotifications: async (userId, payload) => {
        const user = await User.findById(userId);
        if (user && user.preferences.pushNotifications) {
            user.subscriptions.forEach(subscription => {
                webPushService.sendNotification(subscription, payload);
            });
        }
    }
};

5. Lógica del controlador

Manejar rutas API e integrar servicios.

// /controllers/notificationController.js
const notificationService = require('../services/notificationService');

exports.sendNotification = async (req, res, next) => {
    try {
        const { userId, title, body } = req.body;
        const payload = { title, body };
        await notificationService.sendPushNotifications(userId, payload);
        res.status(200).json({ message: 'Notification sent successfully' });
    } catch (error) {
        next(error);
    }
};

6. Enrutamiento

Configura rutas para tu API.

// /routes/notificationRoutes.js
const express = require('express');
const router = express.Router();
const notificationController = require('../controllers/notificationController');

router.post('/send', notificationController.sendNotification);

module.exports = router;

7. Manejo de errores

Centraliza el manejo de errores para garantizar que la aplicación no falle.

// /utils/errorHandler.js
module.exports = (err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send({ error: 'Something went wrong!' });
};

8. Punto de entrada a la aplicación

Inicializa la aplicación y conéctate a la base de datos.

// app.js
const express = require('express');
const mongoose = require('mongoose');
const config = require('config');
const notificationRoutes = require('./routes/notificationRoutes');
const errorHandler = require('./utils/errorHandler');

const app = express();

app.use(express.json());
app.use('/api/notifications', notificationRoutes);
app.use(errorHandler);

mongoose.connect(config.get('db.uri'), {
    useNewUrlParser: true,
    useUnifiedTopology: true
})
    .then(() => console.log('MongoDB connected...'))
    .catch(err => console.error('MongoDB connection error:', err));

const PORT = config.get('server.port');
app.listen(PORT, () => console.log(`Server running in ${config.get('server.env')} mode on port ${PORT}`));

9. Prácticas de seguridad

• Variables de entorno: almacene información confidencial como claves API y URI de bases de datos en variables de entorno.
• HTTPS: entrega tu aplicación a través de HTTPS para asegurar la comunicación entre los clientes y el servidor.
• Política de seguridad de contenido (CSP): implemente encabezados CSP para evitar ataques de secuencias de comandos entre sitios (XSS).
• Limitación de velocidad: utilice middleware como express-rate-limit para proteger su API de ataques de fuerza bruta.

10. Pruebas

Escriba pruebas para garantizar que su servicio funcione como se espera en diversas condiciones.

// /tests/notification.test.js
const request = require('supertest');
const app = require('../app');

describe('Notification API', () => {
    it('should send a notification', async () => {
        const res = await request(app)
            .post('/api/notifications/send')
            .send({ userId: 'someUserId', title: 'Test', body: 'This is a test' });
        expect(res.statusCode).toEqual(200);
        expect(res.body.message).toBe('Notification sent successfully');
    });
});

11. Implementación en producción

• Canalización de CI/CD: configure una canalización de CI/CD utilizando herramientas como Jenkins, GitHub Actions o GitLab CI para automatizar las pruebas, la creación y la implementación de su aplicación.
• Containerización: Dockeriza tu aplicación para garantizar la coherencia en diferentes entornos.
• Monitoreo: utilice herramientas de monitoreo como Prometheus y Grafana para realizar un seguimiento del estado y el rendimiento de su aplicación.

12. Escalado

• Escalado horizontal: implemente varias instancias de su servicio detrás de un equilibrador de carga para manejar un tráfico elevado.
• Escalado de base de datos: implemente conjuntos de fragmentación o réplicas en MongoDB para el escalado horizontal de su base de datos.

Esta configuración de nivel de producción garantiza que su sistema de notificaciones push sea escalable, seguro y mantenible. El código está organizado para permitir pruebas, implementación y monitoreo sencillos, siguiendo las mejores prácticas de la industria. Si tiene más preguntas o necesita detalles de implementación específicos, ¡no dude en preguntar!