Création complète de l'application NoteFlow - Notes & Todo List

Application web Dockerisée moderne avec:
- Backend Node.js + Express + SQLite
- Frontend HTML/CSS/JavaScript vanilla
- Authentification JWT + bcrypt
- Gestion des notes avec images et todos intégrés
- Sidebar todos globaux avec filtres
- Interface utilisateur fluide avec animations CSS
- Administration des utilisateurs
- Sécurité production-ready (Helmet, rate limiting, validation)
- Configuration Docker complète
- Documentation README détaillée

Stack technique:
- Node.js 20 Alpine
- SQLite3 avec indexes optimisés
- Multer pour upload d'images
- Winston pour logging
- Express-validator pour validation
- Architecture modulaire (routes, middleware, config)

Fonctionnalités:
- Notes: CRUD complet, recherche, images, todos intégrés
- Todos globaux: création, toggle, filtres, suppression
- Auth: JWT 24h, bcrypt 12 rounds
- Admin: gestion utilisateurs complète
- UI: masonry grid, modal animations, responsive

Configuration Docker:
- Healthcheck intégré
- Volumes persistants pour data et uploads
- Network nginx_default pour reverse proxy
- Variables d'environnement configurables

Prêt pour déploiement avec: docker-compose up -d

middleware/auth.js

@@ -1,40 +1,75 @@
+// Middleware d'authentification JWT
 const jwt = require('jsonwebtoken');
-const winston = require('winston');
+const logger = require('../config/logger');
 
-// Configure logger
-const logger = winston.createLogger({
-    level: 'info',
-    format: winston.format.combine(
-        winston.format.timestamp(),
-        winston.format.json()
-    ),
-    transports: [
-        new winston.transports.Console()
-    ]
-});
+const JWT_SECRET = process.env.JWT_SECRET || 'change_me_in_production_please_use_strong_secret';
 
-const authMiddleware = (req, res, next) => {
-  try {
-    const token = req.headers.authorization?.split(' ')[1];
-    
-    if (!token) {
-      return res.status(401).json({ message: 'Authentication required' });
+if (JWT_SECRET === 'change_me_in_production_please_use_strong_secret' && process.env.NODE_ENV === 'production') {
+  logger.warn('⚠️  ATTENTION: JWT_SECRET par défaut utilisé en production! Changez-le immédiatement!');
+}
+
+/**
+ * Middleware pour vérifier le token JWT
+ */
+function authenticateToken(req, res, next) {
+  const authHeader = req.headers['authorization'];
+  const token = authHeader && authHeader.split(' ')[1]; // Format: "Bearer TOKEN"
+
+  if (!token) {
+    return res.status(401).json({ error: 'Token d\'authentification manquant' });
+  }
+
+  jwt.verify(token, JWT_SECRET, (err, user) => {
+    if (err) {
+      logger.warn(`Tentative d'accès avec token invalide: ${err.message}`);
+      return res.status(403).json({ error: 'Token invalide ou expiré' });
     }
 
-    const decoded = jwt.verify(token, process.env.JWT_SECRET);
-    req.user = decoded;
+    // Ajouter les informations utilisateur à la requête
+    req.user = user;
     next();
-  } catch (error) {
-    logger.error('Auth middleware error:', error);
-    return res.status(401).json({ message: 'Invalid token' });
-  }
-};
+  });
+}
 
-const adminMiddleware = (req, res, next) => {
-  if (!req.user.is_admin) {
-    return res.status(403).json({ message: 'Admin access required' });
+/**
+ * Middleware pour vérifier que l'utilisateur est admin
+ */
+function requireAdmin(req, res, next) {
+  if (!req.user || !req.user.is_admin) {
+    logger.warn(`Tentative d'accès admin par utilisateur non autorisé: ${req.user?.username || 'unknown'}`);
+    return res.status(403).json({ error: 'Accès réservé aux administrateurs' });
   }
   next();
-};
+}
 
-module.exports = { authMiddleware, adminMiddleware };
+/**
+ * Générer un token JWT
+ */
+function generateToken(user) {
+  const payload = {
+    id: user.id,
+    username: user.username,
+    is_admin: user.is_admin
+  };
+
+  // Token valide pour 24 heures
+  return jwt.sign(payload, JWT_SECRET, { expiresIn: '24h' });
+}
+
+/**
+ * Vérifier un token JWT (sans middleware)
+ */
+function verifyToken(token) {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (err) {
+    return null;
+  }
+}
+
+module.exports = {
+  authenticateToken,
+  requireAdmin,
+  generateToken,
+  verifyToken
+};