coddyger/src/database/mongoose/mongoose-data-access.ts

Coddyger est une bibliothèque JavaScript/TypeScript qui fournit des fonctions communes et des plugins pour la gestion des données, la communication entre services, et des utilitaires avancés pour le développement d'applications.

import mongoose from 'mongoose';
import env from '../../globals';
import coddyger from '../../coddyger';

export class MongooseDataAccess {
	private readonly options: mongoose.ConnectOptions;
	private readonly connectionUri: string;

	constructor(connectionUri?: string) {
		// Options recommandées pour Mongoose 8.x
		this.options = {
			serverSelectionTimeoutMS: 5000,  // Timeout de sélection du serveur
			socketTimeoutMS: 45000,          // Timeout des opérations
			maxPoolSize: 10,                 // Taille maximale du pool de connexions
			minPoolSize: 1,                  // Taille minimale du pool de connexions
			maxIdleTimeMS: 30000,           // Temps maximum d'inactivité d'une connexion
			waitQueueTimeoutMS: 10000,      // Timeout de la file d'attente
		};
		
		// Utiliser l'URI fourni ou construire l'URI par défaut
		this.connectionUri = connectionUri || 
			`${env.database.connectionString}/${env.database.name}?authSource=admin`;
	}

	async connect(uri?: string): Promise<void> {
		try {
			// Utiliser l'URI fourni en paramètre, ou celui du constructeur, ou celui par défaut
			const finalUri = uri || this.connectionUri;

			// Activer le mode strict pour les requêtes
			mongoose.set('strictQuery', true);
			
			const connection = await mongoose.connect(finalUri, this.options);

			if(uri) {
				coddyger.konsole(`✅ MongoDB connecté :: ${finalUri}`);
			} else {
				const dbName = connection.connections[0].name || process.env.DB_NAME || 'non défini';
				coddyger.konsole(`✅ MongoDB connecté :: ${connection.connections[0].host}:${connection.connections[0].port}:${dbName.replace("/undefined", '')}`);
			}

			// Gestion des événements de connexion
			mongoose.connection.on('error', (err) => {
				coddyger.konsole('❌ Erreur de connexion MongoDB', 1);
				console.error(err);
			});

			mongoose.connection.on('disconnected', () => {
				coddyger.konsole('🔌 MongoDB déconnecté', 2);
			});

			mongoose.connection.on('reconnected', () => {
				coddyger.konsole('♻️ MongoDB reconnecté');
			});

			// Gestion propre de la fermeture
			process.on('SIGINT', async () => {
				try {
					await mongoose.connection.close();
					coddyger.konsole('🛑 Connexion MongoDB fermée suite à l\'arrêt de l\'application');
					process.exit(0);
				} catch (err) {
					console.error('Erreur lors de la fermeture de la connexion MongoDB:', err);
					process.exit(1);
				}
			});

		} catch (err: any) {
			coddyger.konsole('Erreur de connexion MongoDB', 1);
			console.error(err);
			throw err;
		}
	}

	/**
	 * Exécute une fonction dans une transaction MongoDB (session)
	 * @param callback - Fonction asynchrone recevant la session mongoose
	 * @returns Résultat de la fonction callback
	 */
	async transaction<T>(callback: (session: mongoose.ClientSession) => Promise<T>): Promise<T> {
		const session = await mongoose.startSession();
		let result: T;
		try {
			await session.startTransaction();
			result = await callback(session);
			await session.commitTransaction();
		} catch (err) {
			await session.abortTransaction();
			throw err;
		} finally {
			session.endSession();
		}
		return result;
	}
}