feat(services): refactor MysqlHandler to improve factorize method

Update the MysqlHandler class in the 'mysql.service.ts':
- Enhance the `factorize` method to handle 'id' in a special manner and create a string of '?' for prepared SQL queries.
- Refactor the `add` method to utilize the updated `factorize` method for constructing SQL queries.
- Update the return types of `getById` and `getByEmail` methods to return an array of IDbUser instead of a single IDbUser instance.
- Rename a private attribute 'Logger' to 'logger'.

Issue: #18
Signed-off-by: Mathis <yidhra@tuta.io>

src/services/mysql.service.ts

@@ -12,6 +12,7 @@ import type { IDbVehicle } from "@interfaces/database/IDbVehicle";
 import type { IUserUpdate } from "@interfaces/services/IUserUpdate";
 import mysql, { type Connection, type ConnectionOptions } from "mysql2";
 import { Logger } from "tslog";
+import { v4 } from "uuid";
 
 const access: ConnectionOptions = {
 	host: `${process.env["MYSQL_HOST"]}`,
@@ -23,7 +24,7 @@ const access: ConnectionOptions = {
 
 class MysqlHandler {
 	private readonly handlerName: string;
-	private Logger: Logger<unknown>;
+	Logger: Logger<unknown>;
 	private Connection: Connection;
 
 	constructor(handlerName?: string) {
@@ -69,19 +70,35 @@ class MysqlHandler {
 	factorize(data: IDbFactorizeInput): Promise<IDbFactorizeOutput> {
 		return new Promise((resolve, reject) => {
 			try {
+				let _id = "";
 				// @ts-ignore
-				data.values.id ? delete data.values.id : null;
+				if (data.values.id) {
+					// @ts-ignore
+					_id = data.values.id;
+					// @ts-ignore
+					delete data.values.id;
+				}
 				const _sqlQueryKeys = Object.keys(data.values).map(
-					(key: string) => `\'${key}\' = ?`,
+					(key: string) => `${key}`,
 				);
 				const values = Object.values(data.values).map((val) => val);
 				this.Logger.debug(
 					`\n\n>-> Factorized ${_sqlQueryKeys.length} keys for a prepare Query.\n>-> Action: ${data.actionName}\n`,
 				);
 				const sqlQueryKeys = _sqlQueryKeys.join(", ");
+				if (_id && _id.length > 2) {
+					this.Logger.trace(`Id post-pushed in factorized data`);
+					values.push(_id);
+				}
+
+				const questionMarksFields = Array(values.length)
+					.fill("?")
+					.join(", ")
+					.toString();
 
 				const factorizedOutput: IDbFactorizeOutput = {
 					_keysTemplate: sqlQueryKeys,
+					_questionMarksFields: questionMarksFields,
 					totalFields: _sqlQueryKeys.length,
 					_valuesArray: values,
 				};
@@ -159,27 +176,41 @@ const MySqlService = {
 				if (!data.id) return reject("Id is undefined");
 				if (data.id.length !== 36) return reject("Id invalid");
 
-				const _sql =
+				// const _values = [
-					"INSERT INTO `users`(`id`,`username`, `firstname`, `lastname`, `dob`, `email`, `is_mail_verified`, `is_admin`, `gdpr`, `hash`) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)";
+				// 	data.id,
-				const _values = [
+				// 	data.username,
-					data.id,
+				// 	data.firstname,
-					data.username,
+				// 	data.lastname,
-					data.firstname,
+				// 	data.dob,
-					data.lastname,
+				// 	data.email,
-					data.dob,
+				// 	data.is_mail_verified,
-					data.email,
+				// 	data.is_admin,
-					data.is_mail_verified,
+				// 	data.gdpr,
-					data.is_admin,
+				// 	data.hash,
-					data.gdpr,
+				// ];
-					data.hash,
+
-				];
+				handler
-				try {
+					.factorize({
-					handler.execute(_sql, _values).then((result) => {
+						values: data,
-						return resolve(result as unknown as IDbStatusResult);
+						actionName: "Inserting new user",
+					})
+					.then((result) => {
+						const valuesArray = result._valuesArray;
+						const template = result._keysTemplate;
+						const _sql = `INSERT INTO users (${template + `, id`}) VALUES(${
+							result._questionMarksFields
+						})`;
+
+						try {
+							handler.Logger.trace(_sql);
+							handler.Logger.trace(valuesArray);
+							handler.execute(_sql, valuesArray).then((result) => {
+								return resolve(result as unknown as IDbStatusResult);
+							});
+						} catch (err: unknown) {
+							reject(err as Error);
+						}
 					});
-				} catch (err: unknown) {
-					reject(err as Error);
-				}
 			});
 		},
 
@@ -215,14 +246,14 @@ const MySqlService = {
 			});
 		},
 
-		getById(handler: MysqlHandler, userId: string): Promise<IDbUser> {
+		getById(handler: MysqlHandler, userId: string): Promise<Array<IDbUser>> {
 			return new Promise((resolve, reject) => {
 				if (userId.length !== 36) return reject("Id invalid");
 				const _sql = "SELECT * FROM `users` WHERE `id` = ?";
 				const _values = [userId];
 				try {
 					handler.execute(_sql, _values).then((result) => {
-						return resolve(result as unknown as IDbUser);
+						return resolve(result as unknown as Array<IDbUser>);
 					});
 				} catch (err: unknown) {
 					reject(err as Error);
@@ -255,17 +286,17 @@ const MySqlService = {
 		 *
 		 * @param {MysqlHandler} handler - The MySQL database handler instance.
 		 * @param {string} email - The email of the user to retrieve.
-		 * @return {Promise<IDbUser>} - A promise that resolves to the retrieved user object.
+		 * @return {Promise<Array<IDbUser>>} - A promise that resolves to the retrieved user object.
 		 * @throws {Error} - If an error occurs while retrieving the user.
 		 */
-		getByEmail(handler: MysqlHandler, email: string): Promise<IDbUser> {
+		getByEmail(handler: MysqlHandler, email: string): Promise<Array<IDbUser>> {
 			return new Promise((resolve, reject) => {
 				if (!email) return reject("email is undefined");
 				const _sql = "SELECT * FROM `users` WHERE `email` = ?";
 				const _values = [email];
 				try {
 					handler.execute(_sql, _values).then((result) => {
-						return resolve(result as unknown as IDbUser);
+						return resolve(result as unknown as Array<IDbUser>);
 					});
 				} catch (err: unknown) {
 					reject(err as Error);