coddyger/src/database/mongoose/mongoose-dao.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 { Model, Document } from 'mongoose';
import { IData, IErrorObject } from '../../interface';
import { defines } from '../../globals';
import { LoggerService, LogLevel } from '../../services';

export class MongoDbDao<T extends Document> implements IData<T> {
	defaultModel!: typeof Model;

	private logError(e: any, method: string): IErrorObject {
		LoggerService.log({ type: LogLevel.Error, content: e, location: 'MongoDbDao', method });
		return { error: true, data: e, message: defines.message.tryCatch };
	}

	/* -----------------------------------
	| ENREGISTRER UN DOCUMENT
	----------------------------------- */
	async save(data: Document | any): Promise<any> {
		try {
			const Q = new this.defaultModel(data);
			const doc: T = await Q.save();
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'save');
		} 
	}

	async saveMany(data: Array<Document>): Promise<any> {
		try {
			const doc: Document[] = await this.defaultModel.insertMany(data);
			if (!doc) throw doc;
			return doc;
		} catch (e) {
			return this.logError(e, 'saveMany');
		}
	}

	async update(params: any, data: Document | any): Promise<any> {
		try {
			const doc: any = await this.defaultModel.updateOne(params, data, { upsert: false });
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'update');
		}
	}

	async updateMany(params: any, data: Document | any): Promise<any> {
		try {
			const doc: any = await this.defaultModel.updateMany(params, data, { upsert: false });
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'updateMany');
		}
	}

	/* -----------------------------------
	| SELECTIONNE DES DOCUMENTS
	----------------------------------- */
	async select(payloads: {
		params?: object;
		excludes?: string;
		page?: number;
		pageSize?: number;
		sort?: string;
		orderBy?: string; 
	}): Promise<any | IErrorObject> {
		try {
			let { page = 1, pageSize = 10, sort: sortBy, orderBy, params, excludes } = payloads;
			page = Math.max(1, page);
			const startIndex = (page - 1) * pageSize;
			const model = this.defaultModel;

			const sortObject: any = sortBy
				? { [sortBy]: orderBy === 'desc' ? -1 : 1 }
				: { createdAt: -1 };

			const [rows, totalRows] = await Promise.all([
				model
					.find(params!, excludes)
					.sort(sortObject)
					.skip(startIndex)
					.limit(pageSize)
					.lean(),
				model.countDocuments(params)
			]);

			if (!rows) return Promise.reject({ rows, totalRows });

			const totalPages = Math.ceil(totalRows / pageSize);
			return {
				rows,
				totalRows,
				totalPages,
				countRowsPerPage: rows.length,
				totalPagesPerQuery: totalPages
			};
		} catch (e: any) {
			return this.logError(JSON.stringify(e), 'select');
		}
	}

	async selectOne(params: object, fields?: string): Promise<any> {
		try {
			const doc = await this.defaultModel.findOne(params, fields).lean();
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'selectOne');
		}
	}

	async selectLatest(status?: string): Promise<any> {
		try {
			let Q: any;

			if (status) {
				Q = await this.defaultModel.findOne({ status }, '-__v', { sort: { createdAt: -1 } }).lean();
			} else {
				Q = await this.defaultModel.findOne().sort({ createdAt: -1 }).lean();
			}
			return Q;
		} catch (e: any) {
			return e;
		}
	}

	async selectLatestWithParams(params: object = {}, excludeFields?: string): Promise<any> {
		try {
			const doc = await this.defaultModel
				.findOne(params, excludeFields)
				.sort({ createdAt: -1 })
				.lean();
			return doc;
		} catch (e: any) {
			return this.logError(e, 'selectLatestWithParams');
		}
	}

	async count(params: object): Promise<any> {
		try {
			const doc: any = await this.defaultModel.countDocuments(params);
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'count');
		}
	}

	async exist(params: object): Promise<any> {
		try {
			const doc: any = await this.defaultModel.countDocuments(params);
			return doc >= 1;
		} catch (e: any) {
			return this.logError(e, 'exist');
		}
	}

	async aggregate(params: Array<any>): Promise<any> {
		try {
			const doc: any = await this.defaultModel.aggregate(params);
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'aggregate');
		}
	}

	async selectHug(params?: any): Promise<any> {
		try {
			const doc = await this.defaultModel.find(params).lean();
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'selectHug');
		}
	}

	/* -----------------------------------
	| SUPPRIMER UN DOCUMENT
	----------------------------------- */
	async remove(params: any): Promise<any> {
		try {
			const doc: any = await this.defaultModel.deleteOne(params);
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'remove');
		}
	}

	async removeMany(params: any): Promise<any> {
		try {
			const doc: any = await this.defaultModel.deleteMany(params);
			return doc || Promise.reject(doc);
		} catch (e: any) {
			return this.logError(e, 'removeMany');
		}
	}
}