@mlagie/sql-connector 2.2.0 → 3.0.0

package/README.md

@@ -5,7 +5,7 @@
 
 [Français](./docs/fr/README_FR.md) | English
 
-sql-connector helps manage MySQL connections, define table schemas, sync tables automatically, and work with database models through a small API.
+sql-connector helps manage MySQL and PostgreSQL connections, define table schemas, sync tables automatically, and work with database models through a small API.
 
 ## Import
 
@@ -15,7 +15,7 @@ const { Schema, connect, logout, Model, ModelInstance, client, sqlTypeMap } = re
 
 ## Database connection
 
-`connect(config)` opens a MySQL connection using a configuration object compatible with mysql2.
+`connect(config, dialect)` opens a database connection. MySQL is used by default; pass `"postgres"` to use PostgreSQL.
 
 ```javascript
 const config = {
@@ -29,6 +29,29 @@ const config = {
 await connect(config);
 ```
 
+### PostgreSQL
+
+PostgreSQL uses the `pg` driver:
+
+```javascript
+const postgresConfig = {
+  host: 'localhost',
+  port: 5432,
+  user: 'postgres',
+  password: 'password',
+  database: 'mydatabase'
+};
+
+await connect(postgresConfig, 'postgres');
+```
+
+Supported dialects are `mysql` and `postgres`.
+
+| Dialect | Identifier quotes | Query placeholders | Boolean defaults |
+|---------|-------------------|--------------------|------------------|
+| MySQL | Backticks | `?` | `1` / `0` |
+| PostgreSQL | Double quotes | `$1`, `$2`, ... | `TRUE` / `FALSE` |
+
 `logout()` closes the active connection.
 
 ```javascript
@@ -122,11 +145,21 @@ const userSchema = new Schema({
 module.exports = new Model("User", userSchema);
 ```
 
+Example with multiple foreign keys:
+
+```javascript
+const orderSchema = new Schema({
+  user_id: { type: Number, foreignKey: 'users(id)' },
+  product_id: { type: Number, foreignKey: 'products.id' }
+});
+```
+
 ## Table synchronization
 
-`Model.syncAllTables()` compares JS schemas with the database and applies only meaningful differences.
+`Model.syncAllTables()` compares JS schemas with the database and applies only meaningful differences. Foreign-key dependencies are created in the required order, and cyclic dependencies are rejected.
 
 - New columns are added automatically.
+- Foreign keys use the `table(column)` format and may be declared on multiple fields.
 
 ```javascript
 await Model.syncAllTables();

package/docs/fr/README_FR.md

@@ -5,7 +5,7 @@
 
 [English](../../README.md) | Français
 
-Le module sql-connector permet de gérer des connexions MySQL, de définir des schémas, de synchroniser automatiquement des tables et d'exposer des modèles pour manipuler les données simplement.
+Le module sql-connector permet de gérer des connexions MySQL et PostgreSQL, de définir des schémas, de synchroniser automatiquement des tables et d'exposer des modèles pour manipuler les données simplement.
 
 ## Importation
 
@@ -15,7 +15,7 @@ const { Schema, connect, logout, Model, ModelInstance, client, sqlTypeMap } = re
 
 ## Connexion à la base
 
-`connect(config)` ouvre une connexion MySQL à partir d'un objet de configuration compatible avec mysql2.
+`connect(config, dialect)` ouvre une connexion à une base de données. MySQL est utilisé par défaut ; utilisez `"postgres"` pour PostgreSQL.
 
 ```javascript
 const config = {
@@ -29,6 +29,29 @@ const config = {
 await connect(config);
 ```
 
+### PostgreSQL
+
+PostgreSQL utilise le driver `pg` :
+
+```javascript
+const postgresConfig = {
+  host: 'localhost',
+  port: 5432,
+  user: 'postgres',
+  password: 'password',
+  database: 'mydatabase'
+};
+
+await connect(postgresConfig, 'postgres');
+```
+
+Les dialectes supportés sont `mysql` et `postgres`.
+
+| Dialecte | Guillemets des identifiants | Placeholders | Valeurs booléennes par défaut |
+|----------|-----------------------------|--------------|-------------------------------|
+| MySQL | Accolades inverses | `?` | `1` / `0` |
+| PostgreSQL | Guillemets doubles | `$1`, `$2`, ... | `TRUE` / `FALSE` |
+
 `logout()` ferme proprement la connexion.
 
 ```javascript
@@ -92,11 +115,21 @@ const userSchema = new Schema({
 module.exports = new Model("User", userSchema);
 ```
 
+Exemple avec plusieurs clés étrangères :
+
+```javascript
+const orderSchema = new Schema({
+  user_id: { type: Number, foreignKey: 'users(id)' },
+  product_id: { type: Number, foreignKey: 'products.id' }
+});
+```
+
 ## Synchronisation des tables
 
-`Model.syncAllTables()` compare les schémas JS avec la base et applique uniquement les différences utiles.
+`Model.syncAllTables()` compare les schémas JS avec la base et applique uniquement les différences utiles. Les dépendances de clés étrangères sont créées dans le bon ordre et les cycles sont rejetés.
 
 - Ajout de colonne: automatique.
+- Les clés étrangères utilisent le format `table(colonne)` et peuvent être déclarées sur plusieurs champs.
 
 ```javascript
 await Model.syncAllTables();

package/index.d.ts

@@ -198,6 +198,29 @@ export class Schema<TSchema extends SchemaDict = SchemaDict> {
  */
 export function connect(config: PoolOptions): Promise<void>;
 
+/**
+ * Establishes a connection to the database using a given configuration.
+ * @param {Object} config Database connection configuration.
+ * @param {string} config.host The database host.
+ * @param {number} config.port The database port.
+ * @param {string} config.user The username for the connection.
+ * @param {string} config.password The password for the connection.
+ * @param {string} config.database The name of the database.
+ * @param {string} dialect The SQL dialect to use (e.g., 'mysql', 'postgres'). defaults to 'mysql'.
+ * @returns {Promise<void>} A promise that resolves when the connection is established.
+ * 
+ * @example
+ * const config = {
+ *   host: 'localhost',
+ *   port: 6666,
+ *   user: 'root',
+ *   password: 'password',
+ *   database: 'mydatabase'
+ * };
+ * await connect(config);
+ */
+export function connect(config: PoolOptions, dialect?: string): Promise<void>;
+
 /**
  * Closes the database connection.
  * This function terminates the active database connection and records a logging message

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "The sql-connector module allows you to manage connections to a MySQL database, define table schemas, and interact with data in a simple and efficient way.",
   "main": "index.js",
   "exports": {
@@ -66,7 +66,8 @@
   "private": false,
   "dependencies": {
     "@mlagie/logger": "1.0.5",
-    "mysql2": "3.23.3"
+    "mysql2": "3.23.3",
+    "pg": "^8.23.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",

package/src/db/connect.js

@@ -1,7 +1,9 @@
 const mysql = require("mysql2");
+const { Pool: PgPool } = require("pg");
 
 const { getConnexion, setConnexion } = require('./connexion');
 const { logs, error } = require("@mlagie/logger");
+const { setGlobalDialect } = require("./dialects");
 
 /**
  * Establishes a connection to the database using a given configuration.
@@ -11,6 +13,7 @@ const { logs, error } = require("@mlagie/logger");
  * @param {string} config.user The username for the connection.
  * @param {string} config.password The password for the connection.
  * @param {string} config.database The name of the database.
+ * @param {string} dialect The SQL dialect to use (e.g., 'mysql', 'postgres'). defaults to 'mysql'.
  * @returns {Promise<void>} A promise that resolves when the connection is established.
  * 
  * @example
@@ -19,12 +22,14 @@ const { logs, error } = require("@mlagie/logger");
  *   port: 6666,
  *   user: 'root',
  *   password: 'password',
- *   database: 'mydatabase'
+ *   database: 'mydatabase',
+ *   dialect: 'postgresql'
  * };
  * await connect(config);
  */
-async function connect(config) {
-    setConnexion(mysql.createPool(config));
+async function connect(config, dialect = 'mysql') {
+    setGlobalDialect(dialect);
+    setConnexion(dialect === 'postgres' ? new PgPool(config) : mysql.createPool(config));
 }
 
 /**

package/src/db/dialects.js

@@ -0,0 +1,159 @@
+// src/db/dialects.js
+const mysql = require('mysql2');
+
+// Ta regex de validation existante (ex: /^[a-zA-Z_][a-zA-Z0-9_]*$/)
+const SAFE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+function normalizeIdentifierPart(part) {
+    return part ? part.trim() : "";
+}
+
+// Fonction maîtresse calquée sur ta logique de sécurité
+function secureEscape(identifier, escapeFn) {
+    if (identifier === "*") return "*";
+
+    if (typeof identifier !== "string" || identifier.length === 0) {
+        throw new Error(`Invalid SQL identifier: ${identifier}`);
+    }
+
+    return identifier.split(".").map(part => {
+        const normalizedPart = normalizeIdentifierPart(part);
+
+        if (normalizedPart === "*") return "*";
+        if (!SAFE_IDENTIFIER.test(normalizedPart)) {
+            throw new Error(`Invalid SQL identifier: ${identifier}`);
+        }
+        // On applique l'échappement propre au dialecte
+        return escapeFn(normalizedPart);
+    }).join(".");
+}
+
+function escapeIdentifierList(identifiers) {
+    return identifiers.map(identifier => secureEscape(identifier, (part) => part)).join(", ");
+}
+
+function isDateLikeType(fieldType) {
+    return ["date", "datetime", "timestamp", "now"].includes(String(fieldType ?? "").toLowerCase());
+}
+
+function isSqlTemporalDefault(defaultValue) {
+    if (typeof defaultValue !== "string") return false;
+
+    const normalizedValue = defaultValue.trim().toUpperCase();
+    return ["CURRENT_TIMESTAMP", "CURRENT_TIMESTAMP()", "NOW", "NOW()"].includes(normalizedValue);
+}
+
+function formatDateDefault(defaultValue, quote) {
+    const formattedDate = defaultValue.toISOString().slice(0, 19).replace("T", " ");
+    return `DEFAULT ${quote}${formattedDate}${quote}`;
+}
+
+function formatStringDefault(defaultValue, quote) {
+    const escapedValue = quote === "'"
+        ? String(defaultValue).replace(/'/g, "''")
+        : String(defaultValue).replace(/"/g, '""');
+    return `DEFAULT ${quote}${escapedValue}${quote}`;
+}
+
+const dialects = {
+    mysql: {
+        name: "mysql",
+        // Sécurisé avec ta validation + mysql.escapeId natif
+        escape: (identifier) => secureEscape(identifier, (part) => mysql.escapeId(part)),
+        escapeValue: (value) => mysql.escape(value),
+        escapeIdentifierList: (identifiers) => escapeIdentifierList(identifiers),
+        getPlaceholder: () => "?",
+        tableSuffix: " ENGINE=InnoDB",
+        uuidQuery: "SELECT UUID();",
+        extractUuid: (rows) => rows?.[0]?.["UUID()"] ?? rows?.["UUID()"],
+        countKey: (row) => row["COUNT(*)"] ?? row["count"] ?? Object.values(row)[0],
+        formatDefaultSql: (defaultValue, fieldType) => {
+            if (defaultValue === undefined) return null;
+            if (defaultValue === null) return "DEFAULT NULL";
+            if (typeof defaultValue === "function") {
+                if (isDateLikeType(fieldType)) return "DEFAULT CURRENT_TIMESTAMP";
+                return dialects.mysql.formatDefaultSql(defaultValue(), fieldType);
+            }
+            if (defaultValue instanceof Date) return formatDateDefault(defaultValue, "\"");
+            if (isSqlTemporalDefault(defaultValue)) return "DEFAULT CURRENT_TIMESTAMP";
+            if (typeof defaultValue === "string") return formatStringDefault(defaultValue, "\"");
+            if (typeof defaultValue === "number" || typeof defaultValue === "bigint") return `DEFAULT ${defaultValue}`;
+            if (typeof defaultValue === "boolean") return `DEFAULT ${defaultValue ? 1 : 0}`;
+            if (typeof defaultValue === "object") return formatStringDefault(JSON.stringify(defaultValue), "\"");
+            return formatStringDefault(defaultValue, "\"");
+        },
+        execute: async (conn, sql, values = []) => {
+            const [rows] = await conn.promise().execute(sql, values);
+            return rows;
+        },
+        getAffectedRows: (executeResult) => {
+            return executeResult && executeResult.affectedRows !== undefined ? executeResult.affectedRows : 0;
+        }
+    },
+    postgres: {
+        name: "postgres",
+        // Sécurisé avec ta validation + standard ANSI SQL (double-quotes doublées pour l'échappement)
+        escape: (identifier) => secureEscape(identifier, (part) => `"${part.replace(/"/g, '""')}"`),  
+        escapeValue: (value) => {
+            if (value === null) return 'NULL';
+            if (typeof value === 'number') return value.toString();
+            if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE';
+            return `'${String(value).replace(/'/g, "''")}'`;
+        },
+        escapeIdentifierList: (identifiers) => escapeIdentifierList(identifiers),
+        getPlaceholder: (index) => `$${index + 1}`,
+        tableSuffix: "",
+        uuidQuery: "SELECT gen_random_uuid() AS uuid;",
+        extractUuid: (rows) => rows?.[0]?.uuid || rows?.uuid,
+        countKey: (row) => row["count"] ?? Object.values(row)[0],
+        formatDefaultSql: (defaultValue, fieldType) => {
+            if (defaultValue === undefined) return null;
+            if (defaultValue === null) return "DEFAULT NULL";
+            if (typeof defaultValue === "function") {
+                if (isDateLikeType(fieldType)) return "DEFAULT CURRENT_TIMESTAMP";
+                return dialects.postgres.formatDefaultSql(defaultValue(), fieldType);
+            }
+            if (defaultValue instanceof Date) return formatDateDefault(defaultValue, "'");
+            if (isSqlTemporalDefault(defaultValue)) return "DEFAULT CURRENT_TIMESTAMP";
+            if (typeof defaultValue === "string") return formatStringDefault(defaultValue, "'");
+            if (typeof defaultValue === "number" || typeof defaultValue === "bigint") return `DEFAULT ${defaultValue}`;
+            if (typeof defaultValue === "boolean") return `DEFAULT ${defaultValue ? "TRUE" : "FALSE"}`;
+            if (typeof defaultValue === "object") return formatStringDefault(JSON.stringify(defaultValue), "'");
+            return formatStringDefault(defaultValue, "'");
+        },
+        execute: async (client, sql, values = []) => {
+            let pgSql = sql;
+            if (sql.includes('?')) {
+                let counter = 1;
+                pgSql = sql.replace(/\?/g, () => `$${counter++}`);
+            }
+            const result = await client.query(pgSql, values);
+            const rows = result.rows || [];
+            rows.rowCount = result.rowCount;
+            return rows;
+        },
+        getAffectedRows: (executeResult) => {
+            return executeResult && executeResult.rowCount !== undefined ? executeResult.rowCount : 0;
+        }
+    }
+};
+
+let currentDialectName = "mysql";
+
+function setGlobalDialect(dialectName) {
+    if (dialectName !== "mysql" && dialectName !== "postgres") {
+        throw new Error(`Unsupported dialect: ${dialectName}`);
+    }
+    currentDialectName = dialectName;
+}
+
+function getDialect() {
+    switch (currentDialectName) {
+        case "postgres":
+            return dialects.postgres;
+        case "mysql":
+            return dialects.mysql;
+    }
+}
+
+module.exports = { getDialect, setGlobalDialect };

package/src/models/Model.js

@@ -4,7 +4,7 @@ const { getConnexion } = require("../db/connexion");
 const { ModelInstance } = require("./ModelInstance");
 const { buildSelect, buildQueryParts } = require("../utils/buildQuery/buildQuery");
 const { getSafe, setSafe } = require("../utils/security/safe");
-const { escapeIdentifier, escapeIdentifierList } = require("../utils/sql");
+const { getDialect } = require("../db/dialects");
 
 function getFieldType(field) {
     if (typeof field === "object") {
@@ -15,39 +15,8 @@ function getFieldType(field) {
     if (field && field.name !== undefined) return field.name;
 }
 
-function isDateLikeType(fieldType) {
-    const normalizedType = String(fieldType ?? "").toLowerCase();
-    return ["date", "datetime", "timestamp", "now"].includes(normalizedType);
-}
-
-function isSqlTemporalDefault(defaultValue) {
-    if (typeof defaultValue !== "string") return false;
-
-    const normalizedValue = defaultValue.trim().toUpperCase();
-    return ["CURRENT_TIMESTAMP", "CURRENT_TIMESTAMP()", "NOW", "NOW()"].includes(normalizedValue);
-}
-
-function formatDefaultSql(defaultValue, fieldType) {
-    if (defaultValue === undefined) return null;
-    if (defaultValue === null) return "DEFAULT NULL";
-
-    if (typeof defaultValue === "function") {
-        if (isDateLikeType(fieldType)) return "DEFAULT CURRENT_TIMESTAMP";
-        return formatDefaultSql(defaultValue(), fieldType);
-    }
-
-    if (defaultValue instanceof Date) {
-        const formattedDate = defaultValue.toISOString().slice(0, 19).replace("T", " ");
-        return `DEFAULT "${formattedDate}"`;
-    }
-
-    if (isSqlTemporalDefault(defaultValue)) return "DEFAULT CURRENT_TIMESTAMP";
-    if (typeof defaultValue === "string") return `DEFAULT "${defaultValue.replace(/"/g, '\\"')}"`;
-    if (typeof defaultValue === "number" || typeof defaultValue === "bigint") return `DEFAULT ${defaultValue}`;
-    if (typeof defaultValue === "boolean") return `DEFAULT ${defaultValue ? 1 : 0}`;
-    if (typeof defaultValue === "object") return `DEFAULT "${JSON.stringify(defaultValue).replace(/"/g, '\\"')}"`;
-
-    return `DEFAULT "${String(defaultValue).replace(/"/g, '\\"')}"`;
+function getForeignKeyReference(foreignKey) {
+    return /^([a-zA-Z_][a-zA-Z0-9_]*)(?:\s*\(\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\)|\s*\.\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*)$/.exec(foreignKey);
 }
 
 function getColumnDefinition(fieldName, field) {
@@ -56,24 +25,28 @@ function getColumnDefinition(fieldName, field) {
     }
 
     const fieldType = getFieldType(field);
-    let colDef;
+    const type = getSafe(sqlTypeMap, fieldType);
+    if (!type) throw new Error(`Field ${fieldName} has unsupported type ${fieldType}.`);
 
+    let colDef;
     if (Array.isArray(field.enum) && field.enum.length > 0) {
         const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
         colDef = `ENUM(${enumValues})`;
     } else {
-        const type = getSafe(sqlTypeMap, fieldType);
-        if (!type) throw new Error(`Field ${fieldName} has unsupported type ${fieldType}.`);
-        colDef = `${type}${(type == "VARCHAR" || type == "INT") ? `(${field.length > 0 ? field.length : 255})` : ""}`;
+        const hasLength = type === "VARCHAR" || (type === "INT" && getDialect().name === "mysql");
+        colDef = `${type}${hasLength ? `(${field.length > 0 ? field.length : 255})` : ""}`;
     }
+
     if (field.required) colDef += ' NOT NULL';
-    const defaultDefinition = formatDefaultSql(field.default, fieldType);
+
+    const defaultDefinition = getDialect().formatDefaultSql(field.default, fieldType);
+
     if (defaultDefinition !== null) colDef += ` ${defaultDefinition}`;
     if (field.unique) colDef += ' UNIQUE';
     if (field.auto_increment) colDef += ' AUTO_INCREMENT';
     if (field.primary_key) colDef += ' PRIMARY KEY'
     if (typeof field.customize === 'string' && field.customize.length != 0) colDef += ` ${field.customize}`;
-    return `${escapeIdentifier(fieldName)} ${colDef}`;
+    return `${getDialect().escape(fieldName)} ${colDef}`;
 }
 
 /**
@@ -111,14 +84,14 @@ class Model {
             dependencies[model.name] = [];
             for (const [_, field] of Object.entries(model.schema.schemaDict)) {
                 if (field && field.foreignKey) {
-                    const refTable = field.foreignKey.split('(')[0].trim();
+                    const reference = getForeignKeyReference(field.foreignKey);
+                    if (!reference) throw new Error(`Invalid foreign key definition for field ${_}.`);
+                    const refTable = reference[1];
                     dependencies[model.name].push(refTable);
                 }
             }
         }
 
-        const conn = getConnexion();
-
         const sorted = [];
         const visited = {};
         function visit(table, stack = []) {
@@ -131,7 +104,10 @@ class Model {
             setSafe(visited, table, 'temp');
             const deps = getSafe(dependencies, table)
             for (const dep of deps) {
-                if (getSafe(modelMap, dep)) visit(dep, [...stack, table]);
+                if (dep !== table && getSafe(modelMap, dep)) {
+                    console.log(`Table ${table} depends on ${dep}.`);
+                    visit(dep, [...stack, table]);
+                }
             }
             setSafe(visited, table, true);
             sorted.push(table);
@@ -144,7 +120,7 @@ class Model {
             const model = getSafe(modelMap, table);
 
             try {
-                await conn.promise().execute(model.generateCreateTableStatement(model.schema.schemaDict));
+                await getDialect().execute(getConnexion(), model.generateCreateTableStatement(model.schema.schemaDict));
                 await logs(`The table ${model.name} has been created or already exists`);
             } catch (err) {
                 error(`Error creating table: ${err} with table name: ${model.name}`);
@@ -166,6 +142,13 @@ class Model {
             const field = getSafe(schema, fieldName);
             let lengthDefault = 255;
 
+            if (field && field.foreignKey) {
+                const reference = getForeignKeyReference(field.foreignKey);
+                if (!reference) throw new Error(`Invalid foreign key definition for field ${fieldName}.`);
+                const referenceColumn = reference[2] || reference[3];
+                foreignKey.push(`FOREIGN KEY (${getDialect().escape(fieldName)}) REFERENCES ${getDialect().escape(reference[1])} (${getDialect().escape(referenceColumn)})`);
+            }
+
             if (!field.type && typeof field == "object" && !(Array.isArray(field.enum) && field.enum.length > 0)) throw new Error(`Field ${fieldName} has no type defined.`);
 
             const fieldType = getFieldType(field);
@@ -175,16 +158,16 @@ class Model {
             }
             if (Array.isArray(field.enum) && field.enum.length > 0) {
                 const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
-                return `${fieldName} ENUM(${enumValues})`;
+                return `${getDialect().escape(fieldName)} ENUM(${enumValues})`;
             }
 
             const type = getSafe(sqlTypeMap, fieldType);
 
             if (!type) throw new Error(`Field ${fieldName} has unsupported type ${field}`);
-
-            return `${fieldName} ${type == "VARCHAR" ? `${type}(${lengthDefault})` : type}`;
+            if (type == "VARCHAR") return `${getDialect().escape(fieldName)} ${type}(${lengthDefault})`;
+            return `${getDialect().escape(fieldName)} ${type}`;
         });
-        return `CREATE TABLE IF NOT EXISTS ${escapeIdentifier(this.name)} (${columns.join(', ')}${foreignKey.length > 0 ? ", " + foreignKey.join(', ') : ""}) ENGINE=InnoDB`;
+        return `CREATE TABLE IF NOT EXISTS ${getDialect().escape(this.name)} (${columns.join(', ')}${foreignKey.length > 0 ? ", " + foreignKey.join(', ') : ""}) ${getDialect().tableSuffix};`;
     }
 
     /**
@@ -195,11 +178,11 @@ class Model {
      */
     async save(data) {
         const keys = Object.keys(data);
-        const sql_request = `INSERT INTO ${escapeIdentifier(this.name)} (${escapeIdentifierList(keys)}) VALUES (${keys.map(() => "?").join(", ")})`;
+        const sql_request = `INSERT INTO ${getDialect().escape(this.name)} (${getDialect().escapeIdentifierList(keys)}) VALUES (${keys.map(() => "?").join(", ")})`;
 
         try {
-            const result = await getConnexion().promise().execute(sql_request, Object.values(data));
-            return result[0];
+            const result = await getDialect().execute(getConnexion(), sql_request, Object.values(data));
+            return result;
         } catch (err) {
             error(`Error inserting data into ${this.name}: ${err}`);
             throw err;
@@ -252,9 +235,9 @@ class Model {
                 if (typeof item === 'string') {
                     if (!item.includes('.')) {
                         if (item.startsWith('name')) {
-                            return `${escapeIdentifier(join.table)}.${escapeIdentifier(item)}`;
+                            return `${join.table}.${item}`;
                         }
-                        return `${escapeIdentifier(this.name)}.${escapeIdentifier(item)}`;
+                        return `${this.name}.${item}`;
                     }
                 }
                 return item;
@@ -262,15 +245,14 @@ class Model {
         }
         let joinClause = "";
         if (join && join.table && join.on) {
-            joinClause = ` INNER JOIN ${escapeIdentifier(join.table)} ON ${join.on}`;
+            joinClause = ` INNER JOIN ${getDialect().escape(join.table)} ON ${join.on}`;
         }
 
         const { sql: whereClause, values } = buildQueryParts(options);
-        const query = `SELECT ${buildSelect(select)} FROM ${escapeIdentifier(this.name)}${joinClause} ${whereClause}`;
+        const query = `SELECT ${buildSelect(select)} FROM ${getDialect().escape(this.name)}${joinClause} ${whereClause}`;
 
         try {
-            const result = await getConnexion().promise().execute(query, values);
-            const rows = result && Array.isArray(result) ? result[0] : result;
+            const rows = await getDialect().execute(getConnexion(), query, values);
 
             if (!rows || rows.length === 0) return [];
 
@@ -290,8 +272,8 @@ class Model {
         try {
             const { sql: whereClause, values } = buildQueryParts(filter);
 
-            const rows = await getConnexion().promise().execute(`SELECT COUNT(*) as count FROM ${escapeIdentifier(this.name)} ${whereClause}`, values);
-            const resultRows = rows && Array.isArray(rows) ? rows[0] : [];
+            const rows = await getDialect().execute(getConnexion(), `SELECT COUNT(*) as count FROM ${getDialect().escape(this.name)} ${whereClause}`, values);
+            const resultRows = rows && Array.isArray(rows) ? rows : [];
 
             if (!resultRows || resultRows.length === 0) return 0;
 
@@ -314,9 +296,9 @@ class Model {
      */
     async customRequest(custom, custom_err_name = "") {
         try {
-            const rows = await getConnexion().promise().execute(custom);
+            const rows = await getDialect().execute(getConnexion(), custom);
 
-            if (rows[0].length == 0) return 0;
+            if (!rows || rows.length === 0) return 0;
 
             return new ModelInstance(this.name, rows[0], this.schema);
         } catch (err) {
@@ -336,10 +318,10 @@ class Model {
     async delete(filter) {
         const { sql: whereClause, values } = buildQueryParts(filter);
 
-        const sql_request = `DELETE FROM ${escapeIdentifier(this.name)} WHERE ${whereClause}`;
+        const sql_request = `DELETE FROM ${getDialect().escape(this.name)} WHERE ${whereClause}`;
         return new Promise((resolve, reject) => {
-            getConnexion().promise().execute(sql_request, values).then((rows) => {
-                if (rows[0].affectedRows === 0) return resolve(0);
+            getDialect().execute(getConnexion(), sql_request, values).then((result) => {
+                if (getDialect().getAffectedRows(result) === 0) return resolve(0);
 
                 return resolve(1);
             }).catch((err) => {
@@ -360,10 +342,10 @@ class Model {
      * @returns {Promise<void>} A promise that resolves when the query execution is complete.
      */
     async dropTable() {
-        const sql_request = `DROP TABLE IF EXISTS ${escapeIdentifier(this.name)};`;
+        const sql_request = `DROP TABLE IF EXISTS ${getDialect().escape(this.name)};`;
 
         try {
-            await getConnexion().promise().execute(sql_request);
+            await getDialect().execute(getConnexion(), sql_request);
         } catch (err) {
             error(`Error executing query drop: ${err}`);
             throw err;
@@ -391,11 +373,13 @@ class Model {
      */
     async generate_uuid(var_uuid = "uuid") {
         try {
-            const uuid = (await getConnexion().promise().execute("SELECT UUID();"))[0][0]["UUID()"];
-            const sql_request = `SELECT COUNT(*) FROM ${escapeIdentifier(this.name)} WHERE ${escapeIdentifier(var_uuid)} = ?;`;
-            const [rows] = await getConnexion().promise().execute(sql_request, [uuid]);
+            const uuidRows = await getDialect().execute(getConnexion(), getDialect().uuidQuery);
+            const uuid = getDialect().extractUuid(uuidRows);
+
+            const sql_request = `SELECT COUNT(*) FROM ${getDialect().escape(this.name)} WHERE ${getDialect().escape(var_uuid)} = ${getDialect().getPlaceholder(0)};`;
+            const rows = await getDialect().execute(getConnexion(), sql_request, [uuid]);
 
-            if (rows[0]['COUNT(*)'] == 0) return uuid;
+            if (getDialect().countKey(rows[0]) == 0) return uuid;
             return null;
         } catch (err) {
             error(`Error executing query gen_uuid: ${err}`);

package/src/models/ModelInstance.js

@@ -2,6 +2,7 @@ const { error } = require("@mlagie/logger");
 const { getConnexion } = require("../db/connexion");
 const { getSafe, setSafe } = require("../utils/security/safe");
 const { buildQueryParts } = require("../utils/buildQuery/buildQuery");
+const { getDialect } = require("../db/dialects");
 
 /**
  * Represents an instance of a database model.
@@ -26,7 +27,7 @@ class ModelInstance {
                 value: data,
                 writable: true,
                 configurable: true,
-                enumerable: true
+                enumerable: false
             },
             _schema: {
                 value: schema,
@@ -81,12 +82,15 @@ class ModelInstance {
      * @throws {Error} Throws an error if the update fails.
      */
     async updateOne(model) {
-        // 1. Paramétrisation sécurisée de la clause SET
         const setKeys = Object.keys(model);
         if (setKeys.length === 0) return 0;
 
-        const setClause = setKeys.map(key => `\`${key}\` = ?`).join(', ');
-        const values = Object.values(model); // On accumule les valeurs à modifier
+        const dialect = getDialect();
+        const values = Object.values(model);
+
+        const setClause = setKeys.map(key => {
+            return `${dialect.escape(key)} = ?`;
+        }).join(', ');
 
         let targetCriteria;
         try {
@@ -123,14 +127,13 @@ class ModelInstance {
         }
 
         const { sql: whereClause, values: whereValues } = buildQueryParts({ where: targetCriteria });
-
         values.push(...whereValues);
 
-        const sql_request = `UPDATE \`${this._name}\` SET ${setClause} ${whereClause}`;
+        const sql_request = `UPDATE ${dialect.escape(this._name)} SET ${setClause} ${whereClause}`;
 
         try {
-            const [result] = await getConnexion().promise().execute(sql_request, values);
-            const affected = result && (result.affectedRows !== undefined ? result.affectedRows : 0);
+            const result = await dialect.execute(getConnexion(), sql_request, values);
+            const affected = dialect.getAffectedRows(result);
 
             if (affected > 0) {
                 const record = this.getRecordData();
@@ -141,7 +144,7 @@ class ModelInstance {
                 }
             }
 
-            return affected;
+            return affected; // On retourne le nombre exact de lignes modifiées (0 ou plus)
         } catch (err) {
             error(`Error executing query updateOne: ${err}`);
             throw err;
@@ -159,12 +162,12 @@ class ModelInstance {
 
         const sql_request = `DELETE FROM ${this._name} ${whereClause}`;
 
-        const rows = await getConnexion().promise().execute(sql_request, values).catch((err) => {
+        const result = await getDialect().execute(getConnexion(), sql_request, values).catch((err) => {
             error(`Error executing query delete: ${err}`);
             throw err;
         });
 
-        return rows[0].affectedRows === 0 ? 0 : 1;
+        return getDialect().getAffectedRows(result) === 0 ? 0 : 1;
     }
 
     /**
@@ -175,12 +178,12 @@ class ModelInstance {
     async deleteOne() {
         const { sql: whereClause, values } = buildQueryParts(this.getRecordData());
         const sql_request = `DELETE FROM ${this._name} ${whereClause}`;
-        const rows = await getConnexion().promise().execute(sql_request, values).catch((err) => {
+        const result = await getDialect().execute(getConnexion(), sql_request, values).catch((err) => {
             error(`Error executing query deleteOne: ${err}`);
             throw err;
         });
 
-        return rows[0].affectedRows === 0 ? 0 : 1;
+        return getDialect().getAffectedRows(result) === 0 ? 0 : 1;
     }
 
     /**
@@ -190,14 +193,14 @@ class ModelInstance {
      * @throws {Error} Throws an error if query execution fails.
      */
     async customRequest(custom) {
-        const rows = await getConnexion().promise().execute(custom).catch((err) => {
+        const rows = await getDialect().execute(getConnexion(), custom).catch((err) => {
             error(`Error executing query: ${err}`);
             throw err;
         });
 
-        if (rows[0].length == 0) return 0;
+        if (!rows || rows.length === 0) return 0;
 
-        return new ModelInstance(this._name, rows[0], this._schema)._data;
+        return new ModelInstance(this._name, rows, this._schema)._data;
     }
 }
 

package/src/utils/buildQuery/buildQuery.js

@@ -1,4 +1,5 @@
-const { escapeIdentifier, escapeOrderDirection, escapeValue } = require("../sql");
+const { getDialect } = require("../../db/dialects");
+const { escapeOrderDirection } = require("../sql");
 const count = require("./count");
 
 function buildGroupByItem(group) {
@@ -9,44 +10,44 @@ function buildGroupByItem(group) {
     if (typeof group === 'object') {
         if (group.dateFormat) {
             const [col, format] = group.dateFormat;
-            sql = `DATE_FORMAT(${escapeIdentifier(col)}, ${escapeValue(format)})`;
+            sql = `DATE_FORMAT(${getDialect().escape(col)}, ${getDialect().escapeValue(format)})`;
         }
         if (group.col) {
-            sql = escapeIdentifier(group.col);
+            sql = getDialect().escape(group.col);
         }
         if (group.as) {
-            sql += ` AS ${escapeIdentifier(group.as)}`;
+            sql += ` AS ${getDialect().escape(group.as)}`;
         }
         return sql;
     }
 
-    return escapeIdentifier(group.trim());
+    return getDialect().escape(group.trim());
 }
 
 function buildField(field) {
     if (typeof field === 'string') {
         if (field === "*") return "*";
-        return escapeIdentifier(field);
+        return getDialect().escape(field);
     }
 
     let sql = '';
 
     if (field.sum)
-        sql = `SUM(${escapeIdentifier(field.sum)})`;
+        sql = `SUM(${getDialect().escape(field.sum)})`;
     else if (field.dateFormat) {
         const [col, format] = field.dateFormat;
-        sql = `DATE_FORMAT(${escapeIdentifier(col)}, ${escapeValue(format)})`;
+        sql = `DATE_FORMAT(${getDialect().escape(col)}, ${getDialect().escapeValue(format)})`;
     }
     else if (field.col)
-        sql = escapeIdentifier(field.col);
+        sql = getDialect().escape(field.col);
     else if (field.distinct)
-        sql = `DISTINCT ${escapeIdentifier(field.distinct)}`;
+        sql = `DISTINCT ${getDialect().escape(field.distinct)}`;
     else if (field.count)
         sql = count(field.count);
     if (field.as)
-        sql += ` AS ${escapeIdentifier(field.as)}`;
+        sql += ` AS ${getDialect().escape(field.as)}`;
     else if (field.sum)
-        sql += ` AS ${escapeIdentifier(field.sum)}`;
+        sql += ` AS ${getDialect().escape(field.sum)}`;
     return sql;
 }
 
@@ -60,7 +61,7 @@ function buildSelect(select = []) {
         .join(',\n');
 }
 
-function buildWhere(where, values = []) {
+function buildWhere(where, values) {
     const conditions = [];
 
     for (const [key, value] of Object.entries(where)) {
@@ -109,20 +110,19 @@ function buildWhere(where, values = []) {
                             .join(",");
 
                         conditions.push(
-                            `${escapeIdentifier(key)} ${operator} (${placeholders})`
+                            `${getDialect().escape(key)} ${operator} (${placeholders})`
                         );
                         values.push(...operatorValue);
                     } else {
-                        conditions.push(`${escapeIdentifier(key)} ${operator} ?`);
+                        conditions.push(`${getDialect().escape(key)} ${operator} ?`);
                         values.push(operatorValue);
                     }
                 }
-
                 continue;
             }
         }
 
-        conditions.push(`${escapeIdentifier(key)} = ?`);
+        conditions.push(`${getDialect().escape(key)} = ?`);
         values.push(value);
     }
 
@@ -159,8 +159,8 @@ function buildQueryParts(options) {
     if (options.orderBy) {
         const order = options.orderBy.map(o =>
             typeof o === 'string'
-                ? escapeIdentifier(o)
-                : `${escapeIdentifier(o.field)} ${escapeOrderDirection(o.direction || 'ASC')}`
+                ? getDialect().escape(o)
+                : `${getDialect().escape(o.field)} ${escapeOrderDirection(o.direction || 'ASC')}`
         );
         parts.push(`ORDER BY ${order.join(', ')}`);
     }

package/src/utils/buildQuery/count.js

@@ -1,11 +1,11 @@
-const { escapeIdentifier, escapeValue } = require("../sql");
+const { getDialect } = require("../../db/dialects");
 
 module.exports = (field) => {
-    if (typeof field === 'string') return `COUNT(${escapeIdentifier(field)})`;
-    if (field instanceof Array && field !== null) return field.map(col => `COUNT(${escapeIdentifier(col)})`).join(' + ');
+    if (typeof field === 'string') return `COUNT(${getDialect().escape(field)})`;
+    if (field instanceof Array && field !== null) return field.map(col => `COUNT(${getDialect().escape(col)})`).join(' + ');
     if (field instanceof Object) {
         const [key, value] = Object.entries(field)[0];
-        return `COUNT(CASE WHEN ${escapeIdentifier(key)} = ${escapeValue(value)} THEN 1 END)`;
+        return `COUNT(CASE WHEN ${getDialect().escape(key)} = ${getDialect().escapeValue(value)} THEN 1 END)`;
     }
     throw new Error("Invalid field type for COUNT. Must be a string, array, or object.");
 } 

package/src/utils/sql.js

@@ -1,37 +1,3 @@
-const { escape, escapeId } = require("mysql2");
-
-const SAFE_IDENTIFIER = /^[A-Za-z0-9_]+$/;
-
-function normalizeIdentifierPart(part) {
-    return String(part).trim().replace(/^`+|`+$/g, "");
-}
-
-function escapeIdentifier(identifier) {
-    if (identifier === "*") return "*";
-
-    if (typeof identifier !== "string" || identifier.length === 0) {
-        throw new Error(`Invalid SQL identifier: ${identifier}`);
-    }
-
-    return identifier.split(".").map(part => {
-        const normalizedPart = normalizeIdentifierPart(part);
-        
-        if (normalizedPart === "*") return "*";
-        if (!SAFE_IDENTIFIER.test(normalizedPart)) {
-            throw new Error(`Invalid SQL identifier: ${identifier}`);
-        }
-        return escapeId(normalizedPart);
-    }).join(".");
-}
-
-function escapeIdentifierList(identifiers) {
-    return identifiers.map(identifier => escapeIdentifier(identifier)).join(", ");
-}
-
-function escapeValue(value) {
-    return escape(value);
-}
-
 function escapeOrderDirection(direction) {
     const normalized = String(direction ?? "ASC").toUpperCase();
 
@@ -43,8 +9,5 @@ function escapeOrderDirection(direction) {
 }
 
 module.exports = {
-    escapeIdentifier,
-    escapeIdentifierList,
-    escapeOrderDirection,
-    escapeValue
+    escapeOrderDirection
 };