AIDE-MEMOIRE NODE.JS - GUIDINEE.COM
Reperes a garder sous la main pendant le projet fil rouge.

=== PRISE EN MAIN ===
- Node.js = executer du JavaScript HORS du navigateur (serveurs, API, outils) via le moteur V8. UN seul langage front + back (full-stack JS).
- Modele ASYNCHRONE NON-BLOQUANT + boucle d'evenements : les operations lentes (I/O) ne bloquent pas ; Node enregistre un rappel et continue. MONO-THREAD mais gere des milliers de connexions.
- Excellent pour l'I/O (serveurs, API, temps reel) ; moins pour le CPU intensif (mono-thread).
- Installer la version LTS (stable, maintenue longtemps). Verifier : node -v, npm -v. VS Code = editeur standard (terminal integre, ESLint/Prettier).
- REPL (node seul) = experimenter ; fichiers .js (node app.js) = developper. console.log pour afficher. Globaux Node : process, __dirname, __filename (PAS de window/document/DOM).

=== JAVASCRIPT & BASES NODE ===
- JS moderne (ES6+) = prerequis. const par defaut, let si reassignation, JAMAIS var. Fonctions flechees, destructuration, template literals, spread/rest.
- map (transformer) / filter (filtrer) / reduce (agreger) : traitement moderne des collections.
- ASYNCHRONE (le coeur de Node) : callbacks (error-first) -> Promises (.then/.catch) -> ASYNC/AWAIT (moderne, lisible, try/catch). Promise.all pour le parallelisme.
- MODULES : CommonJS (require / module.exports) et ES Modules (import / export). Decouper par responsabilite. Chemins locaux en ./
- npm : package.json (manifeste), npm install, dependencies vs devDependencies (-D). package-lock.json fige les versions (reproductibilite).
- VERSIONNER : code + package.json + package-lock.json. PAS node_modules (regenerable) ni .env (secrets) -> .gitignore. SEMVER (^ mineures, ~ correctives). npm audit (vulnerabilites).

=== COEUR DE NODE.JS ===
- Modules NATIFS (aucune install) : fs (fichiers - ASYNCHRONE en serveur, fs.promises + await !), path (chemins PORTABLES, path.join - jamais concatener), os, http, crypto, events, stream.
- EventEmitter (module events) : programmation evenementielle. .on(evt, cb) ecouter | .emit(evt, data) declencher. Toujours ecouter 'error'. De nombreux objets natifs sont des EventEmitters.
- STREAMS : traiter par MORCEAUX (pas tout en memoire) pour les GROS volumes. .pipe() connecte lecture->ecriture. Buffers = donnees binaires. Uploads = toujours en stream.
- Serveur HTTP natif : http.createServer((req, res) => ...).listen(port). req (method, url, headers, body) / res (statusCode, setHeader, end). Formateur AVANT Express.
- HTTP : methodes (GET lire, POST creer, PUT/PATCH modifier, DELETE supprimer) ; codes (200, 201, 400, 401, 403, 404, 500) ; en-tetes (Content-Type, Authorization).

=== EXPRESS & BASES DE DONNEES ===
- EXPRESS (framework de reference, batit sur http) : routage app.get/post/put/delete('/chemin', handler). Routes dynamiques /users/:id -> req.params.id. req.query, req.body. res.json, res.status(201).
- MIDDLEWARE (LE concept cle) : fonction (req, res, next) dans un PIPELINE que la requete traverse. app.use(express.json()) parse le corps. TOUT est middleware (auth, erreurs, static...).
- SSR (templates EJS/Handlebars, res.render) = serveur genere le HTML (sites de contenu, SEO). API + front separe (React/Vue) = Node sert du JSON. express.static('public') pour les assets.
- PERSISTANCE : NoSQL (MongoDB - documents/collections, MONGOOSE = ODM : schemas + validation + modeles ; CRUD asynchrone) ou SQL (PostgreSQL/MySQL - tables/relations, PRISMA/Sequelize = ORM).
- MONGOOSE : TOUJOURS definir un schema (coherence, validation required/unique, securite) meme si MongoDB ne l'impose pas. Hooks (ex. hacher un mot de passe avant save).
- INJECTION SQL (faille critique) : ne JAMAIS concatener des donnees utilisateur -> requetes PARAMETREES (les ORM le font). Principe : ne jamais faire confiance aux entrees.

=== API, AUTH & TEMPS REEL ===
- API REST : RESSOURCES (URL claires au pluriel /users) + METHODES HTTP semantiques + bons CODES de statut + JSON. CRUD : GET liste, GET/:id, POST (201), PUT/PATCH, DELETE.
- STRUCTURER (MVC) : routes/ (URL) + controllers/ (logique) + models/ (donnees) + services/middlewares. express.Router() par ressource. Pagination, versionnage (/api/v1/).
- MOTS DE PASSE : JAMAIS en clair -> HACHAGE bcrypt (sel + lenteur). Comparer a la connexion sans dechiffrer. Ne jamais coder son hachage maison.
- AUTHENTIFICATION (qui ? 401) : JWT (jeton signe auto-porteur, en-tete Authorization) ou sessions. Passport simplifie. AUTORISATION (quel droit ? 403) = distincte.
- SECURITE transversale : Helmet (en-tetes), HTTPS, SECRETS en variables d'environnement (jamais dans le code/Git), rate limiting, validation. « Ne jamais faire confiance aux entrees ».
- TEMPS REEL : WebSockets (connexion PERSISTANTE BIDIRECTIONNELLE, le serveur POUSSE) via SOCKET.IO (evenementiel : emit/on, broadcast, rooms). Node y EXCELLE. Chat, notifications, dashboards live.
- FIABILISER : VALIDATION des entrees (Zod/Joi, rejeter avec 400), GESTION D'ERREURS centralisee (middleware err,req,res,next ; gerer l'async), TESTS (Jest : unitaires + integration).

=== NIVEAU PRO & DEPLOIEMENT ===
- TYPESCRIPT (sur-ensemble de JS, typage statique, compile en JS) : erreurs a la COMPILATION, meilleur outillage, robustesse. Quasi standard en pro. S'apprend progressivement (JS d'abord).
- PERFORMANCE : Node mono-thread -> CLUSTERING (module cluster / PM2 : une instance par coeur). Worker threads pour le CPU. CACHE (Redis - souvent le plus impactant). Optimiser les requetes (indexation, N+1).
- MESURER (profiler) AVANT d'optimiser ; ne pas bloquer la boucle d'evenements ; NE PAS optimiser prematurement (code correct d'abord, mesure, optimisation ciblee). Scaling horizontal (load balancer, apps stateless).
- DOCKER (conteneurisation) : fin du « ca marche sur ma machine ». Dockerfile (recette) -> image -> conteneur. .dockerignore (node_modules). Docker Compose (app + base + cache).
- DEPLOIEMENT : PaaS (Render, Railway - SIMPLE, connecter Git, HTTPS gere - ideal pour debuter) vs VPS (controle + responsabilites) vs cloud (puissant, complexe).
- CI/CD (GitHub Actions) : CI (a chaque push, tester/verifier) + CD (deployer auto si ca passe). Fiabilite, automatisation, tracabilite. Essentiels prod : variables d'environnement (secrets !), HTTPS, logs/monitoring, environnements separes.

RAPPELS
- L'ASYNCHRONE (async/await) est le cap central de Node : le maitriser debloque tout le reste.
- Ne jamais bloquer la boucle d'evenements (asynchrone partout en serveur).
- SECURITE = responsabilite permanente : mots de passe haches (bcrypt), ne jamais faire confiance aux entrees, secrets en variables d'environnement, HTTPS.
- Une API bien CONCUE (conventions REST + structure) vaut mieux qu'une qui « marche » juste. Fiabiliser : validation + gestion d'erreurs + tests.
- Savoir LIVRER (Docker, deploiement, CI/CD) acheve le developpeur autonome : de l'idee au service en ligne fiable.