@mlagie/sql-connector 2.0.0 → 2.0.2

package/eslint.config.mjs

@@ -1,12 +1,37 @@
+import js from "@eslint/js";
 import security from "eslint-plugin-security";
 
 export default [
   {
+    ignores: ["eslint.config.mjs"]
+  },
+  js.configs.recommended,
+  {
+    files: ["**/*.js"],
+    languageOptions: {
+      sourceType: "commonjs",
+      globals: {
+        console: "readonly",
+        exports: "readonly",
+        module: "readonly",
+        process: "readonly",
+        require: "readonly",
+        __dirname: "readonly",
+        __filename: "readonly"
+      }
+    },
     plugins: {
       security
     },
     rules: {
-      ...security.configs.recommended.rules
+      ...security.configs.recommended.rules,
+      "no-unused-vars": [
+        "error",
+        {
+          argsIgnorePattern: "^(?:_|resolve|reject)$",
+          varsIgnorePattern: "^_$"
+        }
+      ]
     }
   }
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "description": "Le module sql-connector permet de gérer les connexions à une base de données MySQL, de définir des schémas de tables, et d'interagir avec les données de manière simple et efficace.",
   "main": "index.js",
   "scripts": {
@@ -36,10 +36,10 @@
   "private": false,
   "dependencies": {
     "@mlagie/logger": "1.0.2",
-    "glob": "^13.0.6",
     "mysql2": "3.22.5"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "eslint": "^10.6.0",
     "eslint-plugin-security": "^4.0.1"
   }

package/releases/2.0.1.md

@@ -0,0 +1,23 @@
+# Release v2.0.1 — Hotfix: Application Launch Crash (Variable Reference Error)
+
+This patch release resolves a critical regression introduced in `v2.0.0` that completely blocked applications from starting when using `@mlagie/sql-connector`.
+
+## Problem
+
+Upon initializing the package or starting the parent application, a runtime crash occurred due to an undefined or incorrectly scoped variable. This prevented the ORM from establishing connections and loading models properly, causing the host application to crash immediately on boot.
+
+## What Was Fixed
+
+* **Variable Scope Resolution:** Fixed the broken variable reference causing the startup crash during initialization.
+* **Boot Reliability:** Restored seamless application launches when importing and configuring the SQL connector.
+
+---
+
+## 📦 Component Impact
+
+| Impacted Area | Description | Status |
+| :--- | :--- | :--- |
+| **Core Initialization** | Uncaught reference/variable error blocking `npm start` | **Fixed** |
+| **Stability** | Application crash on package import | **Resolved** |
+
+*If you encountered initialization errors with v2.0.0, please upgrade your dependency to v2.0.1 immediately.* `npm update @mlagie/sql-connector`

package/releases/2.0.2.md

@@ -0,0 +1,20 @@
+# Release v2.0.2 — Performance Optimization & Code Cleanup
+
+This patch release focuses on optimizing the internal runtime footprint and improving overall execution performance by removing legacy, unused code paths and dependencies.
+
+## What Was Improved
+
+* **Dead Code Elimination:** Removed unused functions, legacy variables, and obsolete logic that were lingering from previous architecture overhauls (such as the old `serveur` logger reference).
+* **Performance Boost:** Cleaning up these elements reduces CPU overhead and memory usage during runtime model instantiation and schema synchronization.
+* **Code Maintenance:** Streamlined internal loops and conditional structures to ensure the ORM remains fast, lightweight, and maintainable.
+
+---
+
+## Component Impact
+
+| Impacted Area | Description | Status |
+| :--- | :--- | :--- |
+| **ModelInstance & Models** | Removal of unused references and obsolete properties | **Optimized** |
+| **Runtime Footprint** | Decreased execution overhead during database mappings | **Improved** |
+
+*This is a fully backward-compatible patch. Upgrading is highly recommended to benefit from the performance improvements.* `npm update @mlagie/sql-connector`

package/src/models/Model.js

@@ -54,35 +54,6 @@ function formatDefaultSql(defaultValue, fieldType) {
     return `DEFAULT "${String(defaultValue).replace(/"/g, '\\"')}"`;
 }
 
-function normalizeDefaultValue(defaultValue, fieldType) {
-    if (defaultValue === undefined) return null;
-    if (defaultValue === null) return "null";
-
-    if (typeof defaultValue === "function") {
-        if (isDateLikeType(fieldType)) return "current_timestamp";
-        return normalizeDefaultValue(defaultValue(), fieldType);
-    }
-
-    if (defaultValue instanceof Date) {
-        return defaultValue.toISOString().slice(0, 19).replace("T", " ");
-    }
-
-    if (isSqlTemporalDefault(defaultValue)) return "current_timestamp";
-    if (typeof defaultValue === "boolean") return defaultValue ? "1" : "0";
-    if (typeof defaultValue === "object") return JSON.stringify(defaultValue);
-
-    return String(defaultValue);
-}
-
-function normalizeDbDefaultValue(defaultValue) {
-    if (defaultValue === null || defaultValue === undefined) return null;
-
-    const normalizedValue = String(defaultValue).trim();
-    if (/^current_timestamp(\(\))?$/i.test(normalizedValue)) return "current_timestamp";
-    if (/^now\(\)$/i.test(normalizedValue)) return "current_timestamp";
-    return normalizedValue;
-}
-
 function generateValueSQL(value) {
     return value.map(item => {
         if (item === null) return 'NULL';
@@ -121,7 +92,7 @@ function getColumnDefinition(fieldName, field) {
     }
 
     const fieldType = getFieldType(field);
-    let colDef = "";
+    let colDef;
 
     if (Array.isArray(field.enum) && field.enum.length > 0) {
         const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
@@ -166,9 +137,9 @@ class Model {
      * @returns {Promise<void>}
      */
     static async syncAllTables() {
-        // Dépendances : {table: [tables dont elle dépend]}
         const dependencies = {};
         const modelMap = {};
+
         for (const model of Model.pendingModels) {
             modelMap[model.name] = model;
             dependencies[model.name] = [];
@@ -181,8 +152,6 @@ class Model {
         }
 
         const conn = getConnexion();
-        const [dbTablesRows] = await conn.promise().query("SHOW TABLES");
-        const dbTables = dbTablesRows.map(row => Object.values(row)[0]);
 
         const sorted = [];
         const visited = {};
@@ -224,7 +193,7 @@ class Model {
     generateCreateTableStatement(schema) {
         let foreignKey = [];
         const columns = Object.keys(schema).map(fieldName => {
-            setSafe(field, schema, fieldName);
+            const field = getSafe(schema, fieldName);
             let lengthDefault = 255;
 
             if (!field.type && typeof field == "object" && !(Array.isArray(field.enum) && field.enum.length > 0)) throw new Error(`Field ${fieldName} has no type defined.`);
@@ -342,18 +311,17 @@ class Model {
 
         const query = `SELECT ${buildSelect(select)} FROM ${this.name}${joinClause} ${buildQueryParts(options)}`;
 
-        return new Promise(async (resolve, reject) => {
-            await getConnexion().promise().query(query).then((result) => {
-                const rows = result && Array.isArray(result) ? result[0] : result;
-                if (!rows || rows.length === 0) return resolve([]);
+        try {
+            const result = await getConnexion().promise().query(query);
+            const rows = result && Array.isArray(result) ? result[0] : result;
+
+            if (!rows || rows.length === 0) return [];
 
-                const instances = rows.map(row => new ModelInstance(this.name, row, this.schema));
-                resolve(instances);
-            }).catch((err) => {
-                error(`Error executing auto-prefixed find: ${err}`);
-                reject(err);
-            });
-        });
+            return rows.map(row => new ModelInstance(this.name, row, this.schema));
+        } catch (err) {
+            error(`Error executing auto-prefixed find: ${err}`);
+            throw err;
+        }
     }
 
     /**
@@ -372,16 +340,16 @@ class Model {
      * @throws {Error} Throws an error if query execution fails.
      */
     async customRequest(custom, custom_err_name = "") {
-        return new Promise(async (resolve, reject) => {
-            await getConnexion().promise().query(custom).then((rows) => {
-                if (rows.length == 0) return resolve(0);
+        try {
+            const rows = await getConnexion().promise().query(custom);
 
-                resolve(new ModelInstance(this.name, rows, this.schema));
-            }).catch((err) => {
-                error(`Error executing query ${custom_err_name}: ${err}`);
-                return;
-            });
-        })
+            if (rows.length == 0) return 0;
+
+            return new ModelInstance(this.name, rows, this.schema);
+        } catch (err) {
+            error(`Error executing query ${custom_err_name}: ${err}`);
+            throw err;
+        }
     }
 
     /**

package/src/models/ModelInstance.js

@@ -3,7 +3,6 @@ const { getConnexion } = require("../db/connexion");
 const formatObject = require("../utils/formatObject");
 const generateCondition = require("../utils/generateCondition");
 const util = require("util");
-const { serveur } = require("@mlagie/logger");
 const { getSafe, setSafe } = require("../utils/security/safe");
 
 /**
@@ -45,7 +44,7 @@ class ModelInstance {
                     get: () => {
                         const val = getSafe(row, key);
                         if (typeof val === 'string' && val.trim().startsWith('{') && val.trim().endsWith('}')) {
-                            try { return JSON.parse(val); } catch (e) { return val; }
+                            try { return JSON.parse(val); } catch { return val; }
                         }
                         return val;
                     },
@@ -99,13 +98,15 @@ class ModelInstance {
             if (typeof rawRec === 'string') {
                 try {
                     rawRec = JSON.parse(rawRec);
-                } catch (e) {  }
+                } catch {
+                    rawRec = recordsArray;
+                }
             }
             const rec = rawRec;
 
             const schemaDict = this.schema && this.schema.schemaDict ? this.schema.schemaDict : null;
             if (schemaDict) {
-                const pkKeys = Object.entries(schemaDict).filter(([k, v]) => v && v.primary_key === true).map(([k]) => k);
+                const pkKeys = Object.entries(schemaDict).filter(([, v]) => v && v.primary_key === true).map(([k]) => k);
                 if (pkKeys.length > 0) {
                     const pkObj = {};
                     for (const k of pkKeys) {
@@ -115,10 +116,11 @@ class ModelInstance {
                 }
             }
             if (!whereClause) whereClause = generateCondition(formatObject(rec), false, this.schema);
-        } catch (e) {
-            let fallbackRec = this.getRecordData();
+        } catch {
+            const originalFallbackRec = this.getRecordData();
+            let fallbackRec = originalFallbackRec;
             if (Array.isArray(fallbackRec)) fallbackRec = fallbackRec[0];
-            if (typeof fallbackRec === 'string') { try { fallbackRec = JSON.parse(fallbackRec); } catch (e) { } }
+            if (typeof fallbackRec === 'string') { try { fallbackRec = JSON.parse(fallbackRec); } catch { fallbackRec = originalFallbackRec; } }
             whereClause = generateCondition(formatObject(fallbackRec), false, this.schema);
         }
 
@@ -152,17 +154,12 @@ class ModelInstance {
     async delete(filter) {
         const sql_request = `DELETE FROM ${this.name} WHERE ${generateCondition(formatObject(filter))}`;
 
-        return new Promise((resolve, reject) => {
-            getConnexion().promise().query(sql_request).then((rows) => {
-
-                if (rows[1] != undefined) return resolve(0);
-
-                resolve(1);
-            }).catch((err) => {
-                error(`Error executing query delete: ${err}`);
-                return 0;
-            });
+        const rows = await getConnexion().promise().query(sql_request).catch((err) => {
+            error(`Error executing query delete: ${err}`);
+            throw err;
         });
+
+        return rows[1] != undefined ? 0 : 1;
     }
 
     /**
@@ -173,16 +170,12 @@ class ModelInstance {
     async deleteOne() {
         const sql_request = `DELETE FROM ${this.name} WHERE ${generateCondition(formatObject(this.getRecordData()))}`;
 
-        return new Promise((resolve, reject) => {
-            getConnexion().promise().query(sql_request).then((rows) => {
-                if (rows[1] != undefined) return resolve(0);
-
-                resolve(1);
-            }).catch((err) => {
-                error(`Error executing query deleteOne: ${err}`);
-                return 0;
-            });
+        const rows = await getConnexion().promise().query(sql_request).catch((err) => {
+            error(`Error executing query deleteOne: ${err}`);
+            throw err;
         });
+
+        return rows[1] != undefined ? 0 : 1;
     }
 
     /**
@@ -192,16 +185,14 @@ class ModelInstance {
      * @throws {Error} Throws an error if query execution fails.
      */
     async customRequest(custom) {
-        return new Promise(async (resolve, reject) => {
-            await getConnexion().promise().query(custom).then((rows) => {
-                if (rows.length == 0) return resolve(0);
-
-                resolve(new ModelInstance(this.name, rows, this.schema)).data;
-            }).catch((err) => {
-                error(`Error executing query: ${err}`);
-                return;
-            });
+        const rows = await getConnexion().promise().query(custom).catch((err) => {
+            error(`Error executing query: ${err}`);
+            throw err;
         });
+
+        if (rows.length == 0) return 0;
+
+        return new ModelInstance(this.name, rows, this.schema).data;
     }
 }
 

package/src/utils/formatObject.js

@@ -2,7 +2,7 @@ const { getSafe, setSafe } = require("./security/safe");
 
 module.exports = function (obj) {
     for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
             const value = getSafe(obj, key);
             if (value instanceof Date) {
                 // convert Date to MySQL DATETIME (no timezone)