WIP: Testing and fixing api endpoints

src/routes/api/canals/+server.ts

@@ -1,90 +0,0 @@
-import { json } from '@sveltejs/kit';
-import prisma from '$lib/prismaClient';
-import redisClient from '$lib/redisClient';
-
-import { json } from '@sveltejs/kit';
-import prisma from '$lib/prismaClient';
-import redisClient from '$lib/redisClient';
-
-// GET: Liste tous les canaux avec leur premier message
-export async function GET() {
-	try {
-		const cachedCanaux = await redisClient.get('canaux');
-
-
-
-		console.log('❌ Cache miss');
-
-		// Si le cache est invalide ou vide, on charge les données depuis la base de données
-		let canaux = await prisma.channel.findMany({
-			include: {
-				messages: {
-					take: 1, // Récupère le dernier message
-					orderBy: { createdAt: 'desc' }, // Trie par date décroissante
-				},
-			},
-		});
-
-		canaux = canaux.sort((a, b) => {
-			const lastMessageA = a.messages[0]?.createdAt || a.createdAt ? a.createdAt : new Date();
-			const lastMessageB = b.messages[0]?.createdAt || b.createdAt ? b.createdAt : new Date();
-			return new Date(lastMessageB).getTime() - new Date(lastMessageA).getTime();
-		});
-
-		return json(canaux);
-
-	} catch (err) {
-		console.error('Erreur lors de la récupération des canaux:', err);
-		return json({ error: 'Erreur serveur' }, { status: 500 });
-	}
-}
-
-export async function POST({ request }) {
-	console.log('Création d’un canal');
-	const { name } = await request.json(); // Récupère le nom du canal depuis la requête
-
-	try {
-		// 1. Créer le canal dans la base de données MongoDB avec Prisma
-		const canal = await prisma.channel.create({
-			data: {
-				name,
-				createdAt: new Date(),
-			},
-		});
-		console.log('Canal créé dans MongoDB:', canal);
-
-		// 2. Récupérer les canaux existants du cache Redis
-		let canaux = await redisClient.get('canaux');
-
-		// Si le cache est vide, initialiser un tableau vide
-		if (canaux) {
-			try {
-				canaux = JSON.parse(canaux); // Parser la liste existante dans Redis
-			} catch (parseError) {
-				console.error('Erreur lors du parsing du cache Redis:', parseError);
-				canaux = []; // Réinitialiser si parsing échoue
-			}
-		} else {
-			canaux = [];
-		}
-
-		// 3. Ajouter le nouveau canal à la liste des canaux en mémoire (Redis)
-		canaux.push(canal); // Ajoute le canal créé dans la base de données à la liste Redis
-
-		// 4. Mettre à jour le cache Redis avec la liste des canaux
-		await redisClient.set('canaux', JSON.stringify(canaux), { EX: 600 }); // Le cache expire dans 10 minutes
-		console.log('Liste des canaux mise à jour dans Redis');
-
-		// 5. Retourner le canal créé dans la réponse
-		return json(canal, { status: 201 });
-
-	} catch (err) {
-		// Gérer les erreurs et les retourner
-		console.error('Erreur lors de la création du canal:', err);
-		return json({ error: 'Erreur lors de la création du canal' }, { status: 500 });
-	}
-}
-
-
-
-

src/routes/api/channels/+server.ts

@@ -0,0 +1,75 @@
+import { json } from '@sveltejs/kit';
+import prisma from '$lib/prismaClient';
+import redisClient from '$lib/redisClient';
+import logger from '$lib/logger';
+
+// GET: Liste tous les canaux avec leur premier message
+export async function GET() {
+	try {
+		const cachedChannels = await redisClient.get('channels');
+
+		if (cachedChannels != null) {
+			logger.debug('Cache entry found, fetching channels from cache');
+			return json(JSON.parse(cachedChannels));
+		}
+
+		logger.debug('No cache entry was found, fetching channels from database');
+		let canaux = await prisma.channel.findMany({
+			include: {
+				messages: {
+					take: 1, // Récupère le dernier message
+					orderBy: { createdAt: 'desc' }, // Trie par date décroissante
+				},
+			},
+		});
+
+		canaux = canaux.sort((a, b) => {
+			const lastMessageA = a.messages[0]?.createdAt || a.createdAt ? a.createdAt : new Date();
+			const lastMessageB = b.messages[0]?.createdAt || b.createdAt ? b.createdAt : new Date();
+			return new Date(lastMessageB).getTime() - new Date(lastMessageA).getTime();
+		});
+
+		logger.debug('Caching channels with EX of 3600 secs');
+		await redisClient.set('channels', JSON.stringify(canaux), { EX: 3600 });
+
+		return json(canaux);
+
+	} catch (err) {
+		logger.error(err)
+		return json({ error: 'Erreur serveur' }, { status: 500 });
+	}
+}
+
+export async function POST({ request }) {
+	const { name } = await request.json();
+
+	try {
+		const canal = await prisma.channel.create({
+			data: {
+				name,
+				createdAt: new Date(),
+			},
+		});
+		logger.debug('Creating a new channel in database with id ' + canal.id);
+
+		const cachedChanels = await redisClient.get('channels');
+		const channels = cachedChanels != null ? JSON.parse(cachedChanels) : [];
+
+		channels.push(canal);
+
+		await redisClient.set('channels', JSON.stringify(channels), { EX: 600 });
+		console.log('Liste des canaux mise à jour dans Redis');
+
+		// 5. Retourner le canal créé dans la réponse
+		return json(canal, { status: 201 });
+
+	} catch (err) {
+		// Gérer les erreurs et les retourner
+		console.error('Erreur lors de la création du canal:', err);
+		return json({ error: 'Erreur lors de la création du canal' }, { status: 500 });
+	}
+}
+
+
+
+

src/routes/api/user/[id]/+server.ts

@@ -1,84 +0,0 @@
-import { json } from '@sveltejs/kit';
-import redisClient from '$lib/redisClient';
-import prisma from '$lib/prismaClient';
-
-export async function GET({ params }) {
-	const userId = params.id;
-
-	try {
-		// Vérifier si l'utilisateur est dans le cache Redis
-		const cachedUser = await redisClient.get(`user:${userId}`);
-		if (cachedUser) {
-			console.log('✅ Cache hit');
-			return json(JSON.parse(cachedUser));
-		}
-
-		console.log('❌ Cache miss');
-		// Si non, récupérer depuis MongoDB via Prisma
-		const user = await prisma.user.findUnique({
-			where: { id: parseInt(userId) },
-		});
-
-		if (!user) {
-			return json({ error: 'Utilisateur non trouvé' }, { status: 404 });
-		}
-
-		// Mettre l'utilisateur en cache
-		await redisClient.set(`user:${userId}`, JSON.stringify(user), { EX: 3600 });
-
-		return json(user);
-	} catch (err) {
-		console.error(err);
-		return json({ error: 'Erreur serveur' }, { status: 500 });
-	}
-}
-
-// Mettre à jour un utilisateur avec PUT
-export async function PUT({ params, request }) {
-	const userId = parseInt(params.id);
-	const { username, surname, name, email, password } = await request.json(); // Assurez-vous d'envoyer tous les champs nécessaires dans le body
-
-	try {
-		// Mettre à jour l'utilisateur dans la base de données
-		const updatedUser = await prisma.user.update({
-			where: { id: userId },
-			data: {
-				username,
-				surname,
-				name,
-				email,
-				password, // Attention à ne pas oublier de sécuriser le mot de passe avec bcrypt ou une autre méthode
-			},
-		});
-
-		// Mettre à jour l'utilisateur dans le cache Redis
-		await redisClient.set(`user:${userId}`, JSON.stringify(updatedUser), 'EX', 3600); // Cache pendant 1 heure (3600 secondes)
-
-		return json(updatedUser);
-	} catch (err) {
-		console.error(err);
-		return json({ error: 'Erreur lors de la mise à jour de l’utilisateur' }, { status: 500 });
-	}
-}
-
-
-export async function DELETE({ params }) {
-	const userId = parseInt(params.id);
-
-	try {
-		await prisma.user.delete({
-			where: { id: userId },
-		});
-
-		// Supprimer l'utilisateur du cache Redis
-		await redisClient.del(`user:${userId}`);
-
-		return json({ message: 'Utilisateur supprimé avec succès' });
-	} catch (err) {
-		console.error(err);
-		return json({ error: 'Erreur lors de la suppression de l’utilisateur' }, { status: 500 });
-	}
-}
-
-
-

src/routes/api/users/+server.ts

@@ -2,26 +2,28 @@
 import { json } from '@sveltejs/kit';
 import redisClient from '$lib/redisClient';
 import prisma from '$lib/prismaClient';
+import logger from '$lib/logger';
 
 export async function GET() {
 	try {
 		// Vérifier si les utilisateurs sont dans le cache Redis
 		const cachedUsers = await redisClient.get('users');
 		if (cachedUsers) {
-			console.log('✅ Cache hit');
+			logger.debug('Cache entry found, fetching users from cache');
 			return json(JSON.parse(cachedUsers));
 		}
 
-		console.log('❌ Cache miss');
+		logger.debug('No cache entry was found, fetching users from database');
 		// Sinon, récupérer les utilisateurs depuis MongoDB
 		const users = await prisma.user.findMany();
 
 		// Mettre les utilisateurs en cache
+		logger.debug('Caching users with EX of 600 secs');
 		await redisClient.set('users', JSON.stringify(users), { EX: 600 });
 
 		return json(users);
 	} catch (err) {
-		console.error(err);
+		logger.error(err);
 		return json({ error: 'Erreur serveur' }, { status: 500 });
 	}
 }
@@ -32,20 +34,29 @@ export async function POST({ request }) {
 	try {
 		const user = await prisma.user.create({
 			data: {
-				username,
+				username: username.toLowerCase(),
 				surname,
 				name,
-				email,
+				email: email.toLowerCase(),
 				password,
 			},
 		});
+		logger.debug('Creating a new user in database with id ' + user.id);
 
 		// Mettre le nouvel utilisateur dans le cache
+		logger.debug(`Caching user (${user.id})`);
+		const cachedUsers = await redisClient.get('users');
+		const usersArray = cachedUsers != null ? JSON.parse(cachedUsers) : [];
+		usersArray.push(user);
+
+		logger.debug(`Added user (${user.id}) to users cache.`);
+		await redisClient.set('users', JSON.stringify(usersArray), { EX: 600 })
+		logger.debug(`Creating a new cache entry with key user:${user.id}, with EX of 3600 secs`);
 		await redisClient.set(`user:${user.id}`, JSON.stringify(user), { EX: 3600 });
 
 		return json(user, { status: 201 });
 	} catch (err) {
-		console.error(err);
+		logger.error(err)
 		return json({ error: 'Erreur lors de la création de l’utilisateur' }, { status: 500 });
 	}
 }

src/routes/api/users/[id]/+server.ts

@@ -0,0 +1,106 @@
+import { json } from '@sveltejs/kit';
+import redisClient from '$lib/redisClient';
+import prisma from '$lib/prismaClient';
+import logger from '$lib/logger';
+
+export async function GET({ params }) {
+	const userId = params.id;
+
+	try {
+		// Vérifier si l'utilisateur est dans le cache Redis
+		const cachedUser = await redisClient.get(`user:${userId}`);
+		if (cachedUser) {
+			logger.debug(`Cache entry found, fetching user (${params.id}) from cache`);
+			return json(JSON.parse(cachedUser));
+		}
+
+		logger.debug(`No cache entry was found, fetching user (${params.id}) from database`);
+		// Si non, récupérer depuis MongoDB via Prisma
+		const user = await prisma.user.findUnique({
+			where: { id: userId },
+		});
+
+		if (!user) {
+			logger.debug(`No record of user (${params.id}) found in database`);
+			return json({ error: 'Utilisateur non trouvé' }, { status: 404 });
+		}
+
+		// Mettre l'utilisateur en cache
+		const cachedUsers = await redisClient.get('users');
+		const usersArray = cachedUsers != null ? JSON.parse(cachedUsers) : [];
+		usersArray.push(user);
+		logger.debug(`Added user (${user.id}) to users cache.`);
+		await redisClient.set('users', JSON.stringify(usersArray), { EX: 600 })
+		logger.debug(`Creating a new cache entry with key user:${user.id}, with EX of 3600 secs`);
+		await redisClient.set(`user:${userId}`, JSON.stringify(user), { EX: 3600 });
+
+		return json(user);
+	} catch (err) {
+		logger.error(err);
+		return json({ error: 'Erreur serveur' }, { status: 500 });
+	}
+}
+
+// Mettre à jour un utilisateur avec PUT
+export async function PUT({ params, request }) {
+	const userId = params.id;
+	const { username, surname, name, email, password } = await request.json();
+
+	try {
+		const updatedUser = await prisma.user.update({
+			where: { id: userId },
+			data: {
+				username,
+				surname,
+				name,
+				email,
+				password, // Attention à ne pas oublier de sécuriser le mot de passe avec bcrypt ou une autre méthode
+			},
+		});
+		logger.debug(`Updated user (${updatedUser.id}) in database`);
+
+		// Mettre à jour l'utilisateur dans le cache Redis
+		const cachedUsers = await redisClient.get('users');
+		let usersArray = cachedUsers != null ? JSON.parse(cachedUsers) : [];
+		usersArray = usersArray.filter((u: { id: string }) => u.id !== updatedUser.id);
+		usersArray.push(updatedUser);
+		logger.debug(`Updated user (${updatedUser.id}) in users cache.`);
+		await redisClient.set('users', JSON.stringify(usersArray), { EX: 600 })
+		logger.debug(`Updated cache entry with key user:${updatedUser.id}`);
+		await redisClient.set(`user:${userId}`, JSON.stringify(updatedUser), { EX: 3600 }); // Cache pendant 1 heure (3600 secondes)
+
+		return json(updatedUser);
+	} catch (err) {
+		logger.error(err);
+		return json({ error: 'Erreur lors de la mise à jour de l’utilisateur' }, { status: 500 });
+	}
+}
+
+
+export async function DELETE({ params }) {
+	const userId = params.id;
+
+	try {
+		const deletedUser = await prisma.user.delete({
+			where: { id: userId },
+		});
+		logger.debug(`Deleted user (${deletedUser.id}) from database.`);
+
+		// Supprimer l'utilisateur du cache Redis
+		const cachedUsers = await redisClient.get('users');
+		let usersArray = cachedUsers != null ? JSON.parse(cachedUsers) : [];
+		usersArray = usersArray.filter((u: { id: string }) => u.id !== deletedUser.id);
+		logger.debug(`Deleted cache entry with key user:${deletedUser.id}`);
+		await redisClient.del(`user:${userId}`);
+		logger.debug(`Deleted user (${deletedUser.id}) from users cache.`);
+		await redisClient.set('users', JSON.stringify(usersArray), { EX: 600 })
+
+		return json({ message: 'Utilisateur supprimé avec succès' });
+	} catch (err) {
+		logger.error(err);
+		return json({ error: 'Erreur lors de la suppression de l’utilisateur' }, { status: 500 });
+	}
+}
+
+
+