@mlagie/sql-connector 1.4.8 → 1.5.0

package/index.d.ts

@@ -95,75 +95,46 @@ export class Model {
     schema: Schema;
     constructor(name: string, schema: Schema);
     /**
-     * Crée toutes les tables dans l'ordre correct en fonction des foreign keys.
+     * Creates all tables in the correct order based on foreign keys.
+     * @param dangerousSync default false
      * @returns {Promise<void>}
      */
-    static syncAllTables({ dangerousSync = false } = {}): Promise<void>;
+    static async syncAllTables(dangerousSync: Object): Promise<void>;
     /**
      * Saves data to the database table.
      * @param {Object} data The data to insert into the table.
      * @returns {Promise<Object>} A promise that resolves with the result of the insertion.
      * @throws {Error} Throws an error if the insert fails.
      */
-    save(data: Record<string, any>): Promise<any>;
+    async save(data: Record<string, any>): Promise<any>;
     /**
      * Récupère plusieurs entrées de la table.
      * @param {Object} [options] - Options de requête (attributs, where, order, limit).
-     * @param {string[]} [options.attributes] - Champs à retourner.
+     * @param {string[]} [options.select] - Champs à retourner.
      * @param {Object} [options.where] - Filtres (clé/valeur).
      * @param {Array} [options.order] - Ex: [['points', 'DESC']]
      * @param {number} [options.limit] - Limite de résultats.
      * @returns {Promise<Array<Object>>}
      */
-    findAll(options?: {
-        attributes?: string[];
+    static async find(options?: {
+        select?: string[];
         where?: Record<string, any>;
         order?: [string, string][];
         limit?: number;
     }): Promise<any[]>;
-    /**
-     * Finds a unique entry in the database table based on the filter provided.
-     * @param {Object} filter An object containing the key-value pairs to use to generate the search condition.
-     * @param {string[]} [fields=["*"]] An array of field names to return in the result.
-     * @returns {Promise<ModelInstance|number>} A promise that resolves to a ModelInstance if an entry is found, otherwise 0.
-     */
-    findOne(filter: Record<string, any>, fields?: string[]): Promise<ModelInstance | number>;
-    /**
-     * Finds a record in the database based on the provided filter.
-     *
-     * @async
-     * @param {Object} filter - The filter criteria for the query. Should be an object where keys are column names and values are the values to filter by.
-     * @param {Array<string>} [fields=["*"]] - The fields to select in the query. Defaults to selecting all fields.
-     * @returns {Promise<ModelInstance|number>} - A promise that resolves to a `ModelInstance` if a record is found, or `0` if no records match the filter.
-     *
-     * @example
-     * // Example usage:
-     * const filter = { id: 1 };
-     * const fields = ["id", "name"];
-     * MyTable.find(filter, fields).then((result) => {
-     *     if (result === 0) {
-     *         console.log("No records found.");
-     *     } else {
-     *         console.log("Record found:", result);
-     *     }
-     * }).catch((err) => {
-     *     console.error("Error:", err);
-     * });
-     */
-    find(filter: Record<string, any>, fields?: string[]): Promise<ModelInstance | number>;
     /**
      * 
      * @param {Object} filter The filter criteria for the query. Should be an object where keys are column names and values are the values to filter by.
      * @returns {Promise<ModelInstance|number>} - A promise that resolves to a `ModelInstance` if a record is found, or `0` if no records match the filter.
      */
-    count(filter?: Record<string, any>): Promise<any>;
+    async count(filter?: Record<string, any>): Promise<any>;
     /**
      * Runs a custom SQL_request query.
      * @param {string} custom The custom SQL_request query to execute.
      * @returns {Promise<void>} A promise that resolves when the query is executed.
      * @throws {Error} Throws an error if query execution fails.
      */
-    customRequest(custom: string): Promise<any>;
+    async customRequest(custom: string): Promise<any>;
     /**
      * Supprime une entrée de la table SQL correspondant au filtre fourni.
      *
@@ -174,7 +145,7 @@ export class Model {
      * ou à une instance de ModelInstance représentant la ligne supprimée.
      * @throws {Error} Lance une erreur si la requête SQL échoue.
      */
-    delete(filter: Record<string, any>): Promise<number | ModelInstance>;
+    async delete(filter: Record<string, any>): Promise<number | ModelInstance>;
     /**
      * Asynchronously drops a table if it exists in the database.
      *
@@ -185,7 +156,7 @@ export class Model {
      *
      * @returns {Promise<void>} A promise that resolves when the query execution is complete.
      */
-    dropTable(): Promise<void>;
+    async dropTable(): Promise<void>;
     /**
      * Generates a unique UUID for the current model.
      *
@@ -205,7 +176,7 @@ export class Model {
      *
      * @throws {Error} If there is an error executing the SQL_request query.
      */
-    generate_uuid(var_uuid?: string): Promise<string | null>;
+    async generate_uuid(var_uuid?: string): Promise<string | null>;
 }
 
 /**
@@ -224,27 +195,27 @@ export class ModelInstance {
      * @returns {int} A promise that resolves with updated data.
      * @throws {Error} Throws an error if the update fails.
      */
-    updateOne(model: Record<string, any>): Promise<number>;
+    async updateOne(model: Record<string, any>): Promise<number>;
     /**
      * Deletes a single entry in the database table.
      * @param {Object} model An object containing the key-value pairs to use for deletion.
      * @returns {Promise<Object>} A promise that resolves with the data deleted.
      * @throws {Error} Throws an error if the deletion fails.
      */
-    delete(filter: Record<string, any>): Promise<number | ModelInstance>;
+    async delete(filter: Record<string, any>): Promise<number | ModelInstance>;
     /**
      * Deletes a single entry in the database table based on the instance data.
      * @returns {Promise<number>} A promise that resolves to the number of rows deleted.
      * @throws {Error} Throws an error if the deletion fails.
      */
-    deleteOne(): Promise<number>;
+    async deleteOne(): Promise<number>;
     /**
      * Runs a custom SQL_request query.
      * @param {string} custom The custom SQL_request query to execute.
      * @returns {Promise<void>} A promise that resolves when the query is executed.
      * @throws {Error} Throws an error if query execution fails.
      */
-    customRequest(custom: string): Promise<any>;
+    async customRequest(custom: string): Promise<any>;
 }
 
 export const client: Record<string, any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlagie/sql-connector",
-  "version": "1.4.8",
+  "version": "1.5.0",
   "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": {
@@ -37,6 +37,6 @@
   "dependencies": {
     "@mlagie/logger": "1.0.2",
     "glob": "^13.0.6",
-    "mysql2": "3.22.4"
+    "mysql2": "3.22.5"
   }
 }

package/releases/1.5.0.md

@@ -0,0 +1,127 @@
+# **Release v1.5 — sql-connector**
+
+## Overview
+
+This release introduces a major improvement to the query system in sql-connector, focusing on flexibility, performance, and developer experience.
+
+The new version simplifies query building, adds support for advanced SQL features (such as aggregation and date formatting), and improves consistency across model operations.
+
+---
+
+## New Features
+
+### Enhanced Query Builder (findAll)
+
+- findAll() now supports advanced SQL features through a clean and extensible configuration object.
+- Developers can build complex queries without writing raw SQL.
+
+Supported features:
+
+- SUM, DATE_FORMAT, and custom field transformations
+- GROUP BY, ORDER BY, HAVING, and LIMIT
+- Multiple aggregations in a single query
+
+Example:
+
+```js
+Model.findAll({
+  select: [
+    { dateFormat: ['date_day', '%Y-%m'], as: 'period' },
+    { sum: 'error' },
+    { sum: 'reload' },
+  ],
+  groupBy: ['period'],
+  orderBy: [{ field: 'period', direction: 'ASC' }]
+});
+```
+
+---
+
+### Dynamic Field Builder
+
+- Query fields are now processed individually through a modular builder.
+- Enables combining multiple transformations (e.g., multiple SUM, DATE_FORMAT) without hardcoding specific cases.
+- Improves extensibility for future SQL functions (AVG, COUNT, etc.).
+
+---
+
+### Simplified Query Construction
+
+- Query generation now follows a fixed SQL order (WHERE → GROUP BY → HAVING → ORDER BY → LIMIT) without unnecessary sorting.
+- Improves performance and avoids overhead from dynamic reordering.
+- Keeps the implementation simple and predictable.
+
+---
+
+### Improved Aggregation Support
+
+- Designed for analytics use cases:
+  - Time-based grouping (day, month, year)
+  - Multi-metric aggregation
+  - Clean integration with frontend dashboards
+
+---
+
+### Better Developer Experience
+
+- No need to write raw SQL for common queries
+- Clear and readable query configuration
+- Consistent API across simple and advanced queries
+
+---
+
+## Improvements
+
+### customRequest function
+
+- customRequest provides all the information instead of taking the first element of the request.
+
+### Model Usage
+
+- findAll() is now instance-based instead of static for better flexibility and dependency injection.
+- Enables multiple database connections and improved testability.
+
+---
+
+### Performance Optimization
+
+- Removed unnecessary iteration and sorting logic in query building.
+- Query generation now runs in constant time structure (no scaling overhead with new features).
+
+---
+
+### Code Maintainability
+
+- Cleaner separation between:
+  - field building
+  - query parts
+  - execution
+
+- Easier to extend without modifying core logic.
+
+## Migration from v1.4.x
+
+### Main changes
+
+1. Switch to instance-based model usage
+2. Update findAll calls to use the new select format
+3. Adapt queries using aggregation to the new field builder system
+
+### Recommendation
+
+- Replace raw SQL queries with the new findAll configuration when possible
+- Review existing analytics queries to leverage built-in aggregation support
+
+## Documentation
+
+See the updated documentation in:
+
+- [README.md](../README.md)
+
+## Useful Links
+
+- GitHub Repository: <https://github.com/lagie-marin/sql-connector>
+
+- npm Package: <https://www.npmjs.com/package/@mlagie/sql-connector>
+
+- Issues: <https://github.com/lagie-marin/sql-connector/issues>

package/src/models/Model.js

@@ -7,6 +7,8 @@ const fs = require('fs');
 const path = require('path');
 const glob = require('glob');
 const { ModelInstance } = require("./ModelInstance");
+const { buildSelect, buildQueryParts } = require("../utils/buildQuery");
+const util = require("util");
 
 function getFieldType(field) {
     if (typeof field === "object") {
@@ -161,7 +163,7 @@ class Model {
     }
 
     /**
-     * Synchronise toutes les tables avec leur schéma JS (création + ajout des colonnes manquantes).
+     * Synchronizes all tables with their JS schemas (creation + adding missing columns).
      * @returns {Promise<void>}
      */
     static async syncAllTables({ dangerousSync = false } = {}) {
@@ -496,6 +498,18 @@ class Model {
         return `CREATE TABLE IF NOT EXISTS ${this.name} (${columns.join(', ')}${foreignKey.length > 0 ? ", " + foreignKey.join(', ') : ""}) ENGINE=InnoDB`;
     }
 
+    getRecordData() {
+        return Array.isArray(this.data) ? this.data[0] ?? this.data : this.data;
+    }
+
+    toJSON() {
+        return this.getRecordData()?.data;
+    }
+
+    [util.inspect.custom]() {
+        return this.getRecordData();
+    }
+
     /**
      * Saves data to the database table.
      * @param {Object} data The data to insert into the table.
@@ -508,7 +522,7 @@ class Model {
 
         try {
             const result = await getConnexion().promise().query(sql_request);
-            return result;
+            return result[0];
         } catch (err) {
             error(`Error inserting data into ${this.name}: ${err}`);
             throw err;
@@ -516,109 +530,44 @@ class Model {
     }
 
     /**
-     * Récupère plusieurs entrées de la table.
-     * @param {Object} [options] - Options de requête (attributs, where, order, limit).
-     * @param {string[]} [options.attributes] - Champs à retourner.
-     * @param {Object} [options.where] - Filtres (clé/valeur).
+     * Retrieves multiple entries from the table.
+     * @param {Object} [options] - Query options (attributes, where, order, limit).
+     * @param {string[]} [options.select] - Champs à retourner.Champs à retourner.
+     * @param {Object} [options.where] - Filters (key/value).
      * @param {Array} [options.order] - Ex: [['points', 'DESC']]
      * @param {number} [options.limit] - Limite de résultats.
      * @returns {Promise<Array<ModelInstance>>}
      */
-    async findAll(options = {}) {
-        const {
-            attributes = ['*'],
-            where = undefined,
-            order = undefined,
-            limit = undefined
-        } = options;
-
-        let sql_request = `SELECT ${attributes.join(', ')} FROM ${this.name}`;
-        if (where) {
-            sql_request += ` WHERE ${generateCondition(formatObject(where))}`;
-        }
-        if (order && Array.isArray(order) && order.length > 0) {
-            const orderStr = order.map(([col, dir]) => `${col} ${dir}`).join(', ');
-            sql_request += ` ORDER BY ${orderStr}`;
-        }
-        if (limit) {
-            sql_request += ` LIMIT ${limit}`;
-        }
-
-        return new Promise((resolve, reject) => {
-            getConnexion().promise().query(sql_request).then(([rows]) => {
-                const instances = rows.map(row => new ModelInstance(this.name, row, this.schema));
-                resolve(instances);
-            }).catch((err) => {
-                error(`Error executing findAll: ${err}`);
-                resolve([]);
-            });
-        });
-    }
-
-    /**
-     * Finds a unique entry in the database table based on the filter provided.
-     * @param {Object} filter An object containing the key-value pairs to use to generate the search condition.
-     * @param {string[]} [fields=["*"]] An array of field names to return in the result.
-     * @returns {Promise<ModelInstance|number>} A promise that resolves to a ModelInstance if an entry is found, otherwise 0.
-     */
-    async findOne(filter, fields = ["*"]) {
-        const sql_request = `SELECT ${fields.join(", ")} FROM ${this.name} WHERE ${generateCondition(formatObject(filter))}`;
+    async find(options = {}) {
+        const { select } = options;
+        const query = `SELECT ${buildSelect(select)} FROM ${this.name} ${buildQueryParts(options)}`;
 
-        return new Promise((resolve, reject) => {
-            getConnexion().promise().query(sql_request).then(([rows]) => {
-                if (!rows || rows.length === 0) return resolve(0);
-                resolve(new ModelInstance(this.name, rows[0], this.schema));
-            }).catch((err) => {
-                error(`Error executing query: ${err}`);
-                return resolve(0);
-            });
-        });
-    }
+        return new Promise(async (resolve, reject) => {
+            await getConnexion().promise().query(query).then((result) => {
+                // Le driver mysql2 renvoie [rows, fields], on isole le tableau de lignes 'rows'
+                const rows = result && Array.isArray(result) ? result[0] : result;
 
-    /**
-     * Finds a record in the database based on the provided filter.
-     *
-     * @async
-     * @param {Object} filter - The filter criteria for the query. Should be an object where keys are column names and values are the values to filter by.
-     * @param {Array<string>} [fields=["*"]] - The fields to select in the query. Defaults to selecting all fields.
-     * @returns {Promise<ModelInstance|number>} - A promise that resolves to a `ModelInstance` if a record is found, or `0` if no records match the filter.
-     *
-     * @example
-     * // Example usage:
-     * const filter = { id: 1 };
-     * const fields = ["id", "name"];
-     * MyTable.find(filter, fields).then((result) => {
-     *     if (result === 0) {
-     *         console.log("No records found.");
-     *     } else {
-     *         console.log("Record found:", result);
-     *     }
-     * }).catch((err) => {
-     *     console.error("Error:", err);
-     * });
-     */
-    async find(filter, fields = ["*"]) {
-        const sql_request = `SELECT ${fields.join(", ")} FROM ${this.name} WHERE ${generateCondition(formatObject(filter))}`;
+                // S'il n'y a aucun résultat, on renvoie un tableau vide [] (et pas 0, c'est plus propre pour faire des .length)
+                if (!rows || rows.length === 0) return resolve([]);
 
-        return new Promise((resolve, reject) => {
-            getConnexion().promise().query(sql_request).then((rows) => {
-                if (rows.length == 0) return resolve(0);
+                // 🚀 LE DÉCALAGE : On transforme chaque ligne brute en une ModelInstance unique
+                const instances = rows.map(row => new ModelInstance(this.name, row, this.schema));
 
-                resolve(new ModelInstance(this.name, rows[0], this.schema));
+                resolve(instances);
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
-                return;
+                error(`Error executing query find: ${err}`);
+                reject(err);
             });
         });
     }
 
     /**
-     * 
+     * Counts the number of records matching the given filter.
      * @param {Object} filter The filter criteria for the query. Should be an object where keys are column names and values are the values to filter by.
      * @returns {Promise<ModelInstance|number>} - A promise that resolves to a `ModelInstance` if a record is found, or `0` if no records match the filter.
      */
     async count(filter) {
-        return this.customRequest(`SELECT COUNT(*) as count FROM ${this.name} ${filter != undefined ? `WHERE ${generateCondition(formatObject(filter))}` : ""}`);
+        return this.customRequest(`SELECT COUNT(*) as count FROM ${this.name} ${filter != undefined ? `WHERE ${generateCondition(formatObject(filter))}` : ""}`, "count");
     }
 
     /**
@@ -627,28 +576,26 @@ class Model {
      * @returns {Promise<void>} A promise that resolves when the query is executed.
      * @throws {Error} Throws an error if query execution fails.
      */
-    async customRequest(custom) {
+    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);
 
-                resolve(new ModelInstance(this.name, rows[0], this.schema));
+                resolve(new ModelInstance(this.name, rows, this.schema));
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
+                error(`Error executing query ${custom_err_name}: ${err}`);
                 return;
             });
         })
     }
 
     /**
-     * Supprime une entrée de la table SQL correspondant au filtre fourni.
+     * Deletes an entry from the SQL table that matches the provided filter.
      *
-     * @async
-     * @function delete
-     * @param {Object} filter - Un objet représentant les conditions de filtre pour la suppression.
-     * @returns {Promise<number>} Une promesse qui se résout à 0 si aucune ligne n'a été supprimée,
-     * ou à une instance de ModelInstance représentant la ligne supprimée.
-     * @throws {Error} Lance une erreur si la requête SQL échoue.
+     * @param {Object} filter An object representing the filter conditions for deletion.
+     * @returns {Promise<number>} A promise that resolves to 0 if no rows were deleted,
+     * or to a ModelInstance representing the deleted row.
+     * @throws {Error} Throws an error if the SQL query fails.
      */
     async delete(filter) {
         const sql_request = `DELETE FROM ${this.name} WHERE ${generateCondition(formatObject(filter))}`;
@@ -658,7 +605,7 @@ class Model {
 
                 return resolve(1);
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
+                error(`Error executing query delete: ${err}`);
                 return 0;
             });
         });
@@ -681,7 +628,7 @@ class Model {
             getConnexion().promise().query(sql_request).then((rows) => {
                 console.log(rows);
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
+                error(`Error executing query drop: ${err}`);
                 return;
             });
         })
@@ -715,7 +662,7 @@ class Model {
                 if (rows[0][0]['COUNT(*)'] == 0) return resolve(uuid);
                 resolve(null);
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
+                error(`Error executing query gen_uuid: ${err}`);
                 return null;
             })
         })

package/src/models/ModelInstance.js

@@ -1,8 +1,9 @@
-const { error, logs } = require("@mlagie/logger");
+const { error } = require("@mlagie/logger");
 const { getConnexion } = require("../db/connexion");
 const formatObject = require("../utils/formatObject");
 const generateCondition = require("../utils/generateCondition");
 const util = require("util");
+const { serveur } = require("@mlagie/logger");
 
 /**
  * Represents an instance of a database model.
@@ -36,6 +37,37 @@ class ModelInstance {
                 enumerable: false
             }
         });
+        const row = this._getTargetRow();
+        if (row && typeof row === 'object') {
+            Object.keys(row).forEach(key => {
+                // On lie dynamiquement la clé de l'instance directement à la case mémoire de 'row'
+                Object.defineProperty(this, key, {
+                    get: () => {
+                        const val = row[key];
+                        // Auto-parse propre du JSON si la colonne MySQL stocke une String JSON
+                        if (typeof val === 'string' && val.trim().startsWith('{') && val.trim().endsWith('}')) {
+                            try { return JSON.parse(val); } catch (e) { return val; }
+                        }
+                        return val;
+                    },
+                    set: (newVal) => {
+                        // L'écriture modifie directement la référence d'origine dans 'row'
+                        row[key] = newVal;
+                    },
+                    enumerable: true, // Permet à JSON.stringify et console.log de voir la propriété
+                    configurable: true
+                });
+            });
+        }
+    }
+
+    /**
+     * Extrait la ligne de données réelle en gérant la structure du driver de BDD [rows, fields]
+     * @private
+     */
+    _getTargetRow() {
+        const rows = Array.isArray(this.data) && Array.isArray(this.data[0]) ? this.data[0] : this.data;
+        return Array.isArray(rows) ? rows[0] : rows;
     }
 
     getRecordData() {
@@ -60,10 +92,24 @@ class ModelInstance {
     async updateOne(model) {
         const setClause = generateCondition(formatObject(model), true);
 
-        // prefer primary key(s) in WHERE to avoid mismatches on nullable/text fields
         let whereClause;
         try {
-            const rec = this.getRecordData();
+            // 1. On récupère le tableau de données
+            const recordsArray = this.getRecordData();
+
+            // 2. On extrait le premier élément (la ligne actuelle)
+            let rawRec = Array.isArray(recordsArray) ? recordsArray[0] : recordsArray;
+
+            // 3. Si cet élément est une chaîne JSON, on le transforme en vrai objet JS
+            if (typeof rawRec === 'string') {
+                try {
+                    rawRec = JSON.parse(rawRec);
+                } catch (e) {
+                    // Pas du JSON valide, on garde la string d'origine
+                }
+            }
+            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);
@@ -77,15 +123,17 @@ class ModelInstance {
             }
             if (!whereClause) whereClause = generateCondition(formatObject(rec), false, this.schema);
         } catch (e) {
-            whereClause = generateCondition(formatObject(this.getRecordData()), false, this.schema);
+            // Fallback de sécurité au cas où
+            let fallbackRec = this.getRecordData();
+            if (Array.isArray(fallbackRec)) fallbackRec = fallbackRec[0];
+            if (typeof fallbackRec === 'string') { try { fallbackRec = JSON.parse(fallbackRec); } catch (e) { } }
+            whereClause = generateCondition(formatObject(fallbackRec), false, this.schema);
         }
-        const sql_request = `UPDATE ${this.name} SET ${setClause} WHERE ${whereClause}`;
 
-        // log SQL for debugging why update may not match
-        try { logs(`ModelInstance.updateOne SQL -> ${sql_request}`); } catch (e) {}
+        const sql_request = `UPDATE ${this.name} SET ${setClause} WHERE ${whereClause}`;
 
         const [result] = await getConnexion().promise().query(sql_request).catch((err) => {
-            error(`Error executing query: ${err}`);
+            error(`Error executing query updateOne: ${err}`);
             throw err;
         });
 
@@ -120,7 +168,7 @@ class ModelInstance {
 
                 resolve(1);
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
+                error(`Error executing query delete: ${err}`);
                 return 0;
             });
         });
@@ -140,7 +188,7 @@ class ModelInstance {
 
                 resolve(1);
             }).catch((err) => {
-                error(`Error executing query: ${err}`);
+                error(`Error executing query deleteOne: ${err}`);
                 return 0;
             });
         });
@@ -157,7 +205,7 @@ class ModelInstance {
             await getConnexion().promise().query(custom).then((rows) => {
                 if (rows.length == 0) return resolve(0);
 
-                resolve(new ModelInstance(this.name, rows[0], this.schema));
+                resolve(new ModelInstance(this.name, rows, this.schema)).data;
             }).catch((err) => {
                 error(`Error executing query: ${err}`);
                 return;
@@ -166,4 +214,4 @@ class ModelInstance {
     }
 }
 
-module.exports = {ModelInstance}
+module.exports = { ModelInstance }