bv-express 1.0.0

package/.env.example

@@ -0,0 +1,5 @@
+PORT=3000
+DB_HOST=localhost
+DB_USER=root
+DB_PASS=
+DB_NAME=moto

package/README.md

@@ -0,0 +1,140 @@
+# 🏍️ BV Express
+
+API Express avec l'intégration du builder bvbuilder
+
+---
+
+## 📋 Table des matières
+
+- [Installation & Configuration](#-installation--configuration)
+- [Lancement du Projet](#-lancement-du-projet)
+- [Fonctionnalités Principales](#-fonctionnalités-principales)
+- [Documentation API](#-documentation-api-swagger)
+- [Tests](#-tests)
+- [Structure du Projet](#-structure-du-projet)
+- [Technologies Utilisées](#-technologies-utilisées)
+- [Contribution](#-contribution)
+
+---
+
+## 🚀 Installation & Configuration
+
+### Prérequis
+
+- Node.js (version 14 ou supérieure)
+- npm
+- Mysql
+
+### Installation des dépendances
+
+```bash
+npm install
+```
+
+### Configuration des variables d'environnement
+
+Le projet nécessite un fichier `.env` pour fonctionner correctement . 
+
+1. Copiez le fichier d'exemple :
+```bash
+cp .env.example .env
+```
+
+2. Éditez le fichier `.env` avec vos propres paramètres :
+```env
+# Exemple de configuration
+PORT=3000
+DB_HOST=localhost
+DB_USER=
+DB_PASS=
+DB_NAME=moto
+```
+
+---
+
+## 🏃 Lancement du Projet
+
+### Mode Développement
+Avec rechargement automatique à chaque modification :
+```bash
+npm run dev
+```
+
+### Mode Production
+```bash
+npm start
+```
+
+L'API sera accessible par défaut sur `http://localhost:3000`
+
+---
+
+## ✨ Fonctionnalités Principales
+
+- ** Authentification JWT** : Sécurisation des accès par jeton JSON Web Token
+---
+
+## 📖 Documentation API (Swagger)
+
+Accédez à la documentation interactive pour tester les endpoints et consulter les schémas de données :
+
+🔗 **[http://localhost:3000/api-docs](http://localhost:3000/api-docs)**
+
+La documentation Swagger vous permet de :
+- Visualiser tous les endpoints disponibles
+- Tester les requêtes directement depuis l'interface
+- Consulter les schémas de requête et de réponse
+- Voir les codes de statut et messages d'erreur
+
+---
+
+## 🧪 Tests
+
+Le projet intègre des tests unitaires pour garantir la fiabilité des fonctionnalités :
+
+```bash
+npm test
+```
+
+Pour exécuter les tests avec la couverture de code :
+```bash
+npm run test:coverage
+```
+
+---
+
+## 📁 Structure du Projet
+
+```
+bbv-express/
+├── src/
+│   ├── controllers/     # Logique métier des routes
+│   ├── models/          # Modèles de données
+│   ├── routes/          # Définition des routes API
+│   ├── middlewares/     # Middlewares (auth, validation, etc.)
+│   └── config/          # Configuration de l'application
+├── tests/               # Tests unitaires et d'intégration
+├── .env                 # Configuration
+├── .env.example         # Exemple de configuration
+├── .gitignore
+├── package.json
+└── README.md
+```
+
+---
+
+## 🛠️ Technologies Utilisées
+
+- **Node.js** - Environnement d'exécution JavaScript
+- **Bvbuilder** - Permet de build, model,controller, route et table via commande
+- **Express.js** - Framework web minimaliste
+- **MySql** - Base de données SQL
+- **JWT** - Authentification par jetons
+- **Swagger** - Documentation API interactive
+- **Jest** - Framework de tests
+
+---
+
+## 📧 Contact
+
+Pour toute question ou suggestion, n'hésitez pas à me contacter.

package/index.js

@@ -0,0 +1 @@
+console.log('Happy developing ✨')

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "bv-express",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node src/server.js",
+    "dev": "nodemon src/server.js",
+    "test": "jest --watchAll --verbose"
+  },
+  "private": false,
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Xenozn/bv-express.git"
+  },
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "cors": "^2.8.5",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "jsonwebtoken": "^9.0.3",
+    "mysql2": "^3.16.0",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.1"
+  },
+  "devDependencies": {
+    "bvbuilder": "^1.0.2",
+    "jest": "^30.2.0",
+    "nodemon": "^3.1.11",
+    "supertest": "^7.2.2"
+  }
+}

package/src/app.js

@@ -0,0 +1,78 @@
+const express = require('express');
+require('dotenv').config();
+const path = require('node:path');
+const fs = require('node:fs'); // Ajouté pour lire les dossiers
+
+const logger = require('./middlewares/logger');
+const swaggerUi = require('swagger-ui-express');
+const swaggerJsdoc = require('swagger-jsdoc');
+
+const app = express();
+
+// --- CONFIGURATION SWAGGER ---
+const swaggerOptions = {
+    definition: {
+        openapi: '3.0.0',
+        info: {
+            title: 'BV Express API Documentation',
+            version: '1.0.0',
+            description: 'Documentation interactive de mon API',
+        },
+        servers: [{ url: 'http://localhost:3000' }],
+
+        components: {
+            securitySchemes: {
+                bearerAuth: {
+                    type: 'http',
+                    scheme: 'bearer',
+                    bearerFormat: 'JWT',
+                },
+            },
+        },
+
+        security: [
+            {
+                bearerAuth: [],
+            },
+        ],
+    },
+    apis: [path.join(__dirname, './v*/routes/*.js')],
+};
+
+
+const swaggerDocs = swaggerJsdoc(swaggerOptions);
+
+// --- MIDDLEWARES ---
+app.use(express.json());
+app.use(logger);
+
+// --- CHARGEMENT AUTOMATIQUE DES ROUTES ---
+const versions = fs.readdirSync(__dirname).filter(file => {
+    const filePath = path.join(__dirname, file);
+    return fs.statSync(filePath).isDirectory() && /^v\d+$/.test(file);
+});
+// Dans ton app.js, remplace la boucle par celle-ci :
+versions.forEach(version => {
+    const routesPath = path.join(__dirname, version, 'routes');
+
+    if (fs.existsSync(routesPath)) {
+        fs.readdirSync(routesPath).forEach(file => {
+            if (!file.endsWith('.js')) return;
+
+            let routeName = file.replace('Routes.js', '').toLowerCase();
+            if (routeName !== 'auth' && !routeName.endsWith('s')) {
+                routeName += 's';
+            }
+            const route = require(`./${version}/routes/${file}`);
+            app.use(`/api/${version}/${routeName}`, route);
+
+            console.log(`✅ Route chargée : /api/${version}/${routeName}`);
+        });
+    }
+});
+
+
+// --- DOCS ---
+app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerDocs));
+
+module.exports = app;

package/src/config/db.js

@@ -0,0 +1,11 @@
+const mysql = require('mysql2');
+require('dotenv').config();
+
+const pool = mysql.createPool({
+    host: process.env.DB_HOST,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASS,
+    database: process.env.DB_NAME
+});
+
+module.exports = pool.promise();

package/src/middlewares/authMiddleware.js

@@ -0,0 +1,27 @@
+const jwt = require('jsonwebtoken');
+const authMiddleware = (req, res, next) => {
+    const token = req.headers['authorization']?.split(' ')[1];
+
+    if (!token) {
+        return res.status(403).json({ message: "Token requis" });
+    }
+
+    try {
+        const decoded = jwt.verify(
+            token,
+            process.env.JWT_SECRET || 'secret_par_defaut'
+        );
+
+        req.userId = decoded.id;
+        req.userRole = decoded.role;
+
+        next();
+    } catch (error) {
+        console.error('JWT error details:', error);
+        return res.status(401).json({
+            message: "Token invalide",
+        });
+    }
+};
+
+module.exports = authMiddleware;

package/src/middlewares/logger.js

@@ -0,0 +1,6 @@
+const logger = (req, res, next) => {
+    console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
+    next();
+};
+
+module.exports = logger;

package/src/middlewares/roleMiddleware.js

@@ -0,0 +1,9 @@
+exports.isAdmin = (req, res, next) => {
+    // req.userRole doit être injecté par ton authMiddleware
+    if (req.userRole !== 'admin') {
+        return res.status(403).json({
+            message: "Accès interdit : privilèges administrateur requis"
+        });
+    }
+    next();
+};

package/src/server.js

@@ -0,0 +1,8 @@
+require('dotenv').config();
+const app = require('./app');
+
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+    console.log(`🚀 Serveur démarré sur http://localhost:${PORT}`);
+});

package/src/v1/controllers/authController.js

@@ -0,0 +1,64 @@
+const User = require('../models/userModel'); // Import du modèle
+const bcrypt = require('bcryptjs');
+const jwt = require('jsonwebtoken');
+
+// --- REGISTER ---
+exports.register = async (req, res) => {
+    const { email, password, nom, prenom } = req.body;
+
+    try {
+        const existingUser = await User.findByEmail(email);
+        if (existingUser) {
+            return res.status(400).json({ message: "Utilisateur déjà existant" });
+        }
+
+        const hashedPassword = await bcrypt.hash(password, 10);
+        const forcedRole = 'user';
+
+        const userId = await User.create({
+            email,
+            password: hashedPassword,
+            nom,
+            prenom,
+            role: forcedRole
+        });
+
+        res.status(201).json({
+            message: "Utilisateur créé !",
+            user: { id: userId, email, nom, prenom, role: forcedRole }
+        });
+
+    } catch (error) {
+        res.status(500).json({ status: "error", message: error.message });
+    }
+};
+
+// --- LOGIN ---
+exports.login = async (req, res) => {
+    const { email, password } = req.body;
+
+    try {
+        const user = await User.findByEmail(email);
+
+        if (!user || !(await bcrypt.compare(password, user.password))) {
+            return res.status(401).json({ message: "Identifiants invalides" });
+        }
+
+        const token = jwt.sign(
+            { id: user.id, role: user.role },
+            process.env.JWT_SECRET || 'secret_par_defaut',
+            { expiresIn: '1h' }
+        );
+
+        const { password: _, ...userWithoutPassword } = user;
+
+        res.json({
+            message: "Connecté !",
+            token,
+            user: userWithoutPassword
+        });
+
+    } catch (error) {
+        res.status(500).json({ status: "error", message: error.message });
+    }
+};

package/src/v1/controllers/userController.js

@@ -0,0 +1,34 @@
+const User = require('../models/userModel');
+
+// --- RÉCUPÉRER MON PROFIL (Via Token) ---
+exports.getMe = async (req, res) => {
+    try {
+        // req.userId est injecté par votre authMiddleware
+        const user = await User.findById(req.userId);
+
+        if (!user) {
+            return res.status(404).json({ message: "Utilisateur non trouvé" });
+        }
+
+        res.json({ status: "success", data: user });
+    } catch (error) {
+        res.status(500).json({ status: "error", message: error.message });
+    }
+};
+
+// --- RÉCUPÉRER UN UTILISATEUR PAR ID (Paramètre URL) ---
+exports.getUserById = async (req, res) => {
+    const { id } = req.params;
+
+    try {
+        const user = await User.findById(id);
+
+        if (!user) {
+            return res.status(404).json({ message: "Utilisateur non trouvé" });
+        }
+
+        res.json({ status: "success", data: user });
+    } catch (error) {
+        res.status(500).json({ status: "error", message: error.message });
+    }
+};

package/src/v1/models/userModel.js

@@ -0,0 +1,34 @@
+const db = require('../../config/db');
+
+const User = {
+    // Trouver un utilisateur par son email
+    findByEmail: async (email) => {
+        const [rows] = await db.query('SELECT * FROM users WHERE email = ?', [email]);
+        return rows[0];
+    },
+
+    // Créer un nouvel utilisateur
+    create: async (userData) => {
+        const { email, password, nom, prenom, role } = userData;
+        const [result] = await db.query(
+            'INSERT INTO users (email, password, nom, prenom, role) VALUES (?, ?, ?, ?, ?)',
+            [email, password, nom, prenom, role]
+        );
+        return result.insertId;
+    },
+
+    findById: async (id) => {
+        const [rows] = await db.query(
+            'SELECT id, email, nom, prenom, role, createdAt FROM users WHERE id = ?',
+            [id]
+        );
+        return rows[0]; // Retourne l'utilisateur ou undefined
+    },
+    findAll: async () => {
+        const [rows] = await db.query('SELECT id, email, nom, prenom, role, createdAt FROM users');
+        return rows;
+    }
+
+};
+
+module.exports = User;

package/src/v1/routes/authRoutes.js

@@ -0,0 +1,56 @@
+const express = require('express');
+const router = express.Router();
+const authController = require('../controllers/authController');
+
+/**
+ * @swagger
+ * /api/v1/auth/register:
+ *   post:
+ *     summary: Inscrire un utilisateur
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               email:
+ *                 type: string
+ *               password:
+ *                 type: string
+ *               nom:
+ *                 type: string
+ *               prenom:
+ *                 type: string
+ *     responses:
+ *       201:
+ *         description: Succès
+ */
+router.post('/register', authController.register);
+
+/**
+ * @swagger
+ * /api/v1/auth/login:
+ *   post:
+ *     summary: Se connecter
+ *     tags: [Auth]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               email:
+ *                 type: string
+ *               password:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: Connexion réussie
+ */
+router.post('/login', authController.login);
+
+
+module.exports = router;

package/src/v1/routes/userRoutes.js

@@ -0,0 +1,49 @@
+const express = require('express');
+const router = express.Router();
+const userController = require('../controllers/userController');
+const authMiddleware = require('../../middlewares/authMiddleware');
+const { isAdmin } = require('../../middlewares/roleMiddleware');
+
+/**
+ * @swagger
+ * /api/v1/users/me:
+ *   get:
+ *     summary: Récupérer les informations de l'utilisateur connecté
+ *     tags: [Users]
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: Informations de l'utilisateur connecté
+ *       401:
+ *         description: Non authentifié
+ */
+router.get('/me', authMiddleware, userController.getMe);
+
+/**
+ * @swagger
+ * /api/v1/users/{id}:
+ *   get:
+ *     summary: Récupérer un utilisateur par ID (admin uniquement)
+ *     tags: [Users]
+ *     security:
+ *       - bearerAuth: []
+ *     parameters:
+ *       - in: path
+ *         name: id
+ *         required: true
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: Utilisateur trouvé
+ *       401:
+ *         description: Non authentifié
+ *       403:
+ *         description: Accès refusé (admin requis)
+ *       404:
+ *         description: Utilisateur non trouvé
+ */
+router.get('/:id', authMiddleware, isAdmin, userController.getUserById);
+
+module.exports = router;

package/tests/auth.test.js

@@ -0,0 +1,52 @@
+const request = require('supertest');
+const app = require('../src/app');
+const db = require('../src/config/db');
+const bcrypt = require('bcryptjs');
+
+// Mock de la base de données
+jest.mock('../src/config/db');
+
+describe('Auth API - Login', () => {
+
+    it('devrait retourner un token 200 si les identifiants sont corrects', async () => {
+        const hashedPassword = await bcrypt.hash('password123', 10);
+        const mockUser = {
+            id: 1,
+            email: 'test@example.com',
+            password: hashedPassword,
+            nom: 'Test',
+            prenom: 'User',
+            role: 'user'
+        };
+
+        db.query.mockResolvedValue([[mockUser]]);
+
+        const res = await request(app)
+            .post('/api/v1/auth/login')
+            .send({
+                email: 'test@example.com',
+                password: 'password123'
+            });
+
+        // 3. Vérifications (Assertions)
+        expect(res.statusCode).toEqual(200);
+        expect(res.body).toHaveProperty('token');
+        expect(res.body.user.email).toBe('test@example.com');
+        expect(res.body.message).toBe('Connecté !');
+    });
+
+    it('devrait retourner 401 si le mot de passe est faux', async () => {
+        const hashedPassword = await bcrypt.hash('correct_password', 10);
+        db.query.mockResolvedValue([[{ email: 'test@example.com', password: hashedPassword }]]);
+
+        const res = await request(app)
+            .post('/api/v1/auth/login')
+            .send({
+                email: 'test@example.com',
+                password: 'wrong_password'
+            });
+
+        expect(res.statusCode).toEqual(401);
+        expect(res.body.message).toBe('Identifiants invalides');
+    });
+});