@igojs/db 6.0.0-beta.2 → 6.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igojs/db",
-  "version": "6.0.0-beta.2",
+  "version": "6.0.0-beta.4",
   "description": "Igo ORM - Database abstraction layer for MySQL and PostgreSQL",
   "main": "index.js",
   "scripts": {
@@ -14,6 +14,11 @@
   ],
   "author": "@igocreate",
   "license": "ISC",
+  "homepage": "https://github.com/igocreate/igo",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:igocreate/igo.git"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -21,7 +26,7 @@
     "lodash": "^4.17.21"
   },
   "optionalDependencies": {
-    "mysql2": "^3.15.3",
+    "mysql2": "^3.16.0",
     "pg": "^8.16.3"
   }
 }

package/src/Db.js

@@ -81,11 +81,9 @@ class Db {
         return dialect.getRows(result);
 
       } catch (err) {
-        if (options.silent) {
-          return;
+        if (!options.silent) {
+          logQuery(sql, params, err);
         }
-        // log & rethrow error
-        logQuery(sql, params, err);
         throw err;
 
       } finally {

package/src/PaginatedOptimizedSql.js

@@ -108,6 +108,12 @@ module.exports = class PaginatedOptimizedSql extends Sql {
 
     // WHERE de la table principale
     const params = [];
+
+    // Ajouter les params des jointures de tri (extraWhere)
+    if (this._sortJoinParams && this._sortJoinParams.length > 0) {
+      params.push(...this._sortJoinParams);
+    }
+
     sql += this.whereSQL(params);
 
     // WHERE NOT de la table principale
@@ -657,6 +663,7 @@ module.exports = class PaginatedOptimizedSql extends Sql {
     const { query, dialect } = this;
     const { esc } = dialect;
     const mainTable = query.table;
+    const params = [];
 
     let sql = '';
     const processedTables = new Set(); // Pour éviter les doublons
@@ -672,17 +679,29 @@ module.exports = class PaginatedOptimizedSql extends Sql {
           return;
         }
 
-        const [, , AssociatedModel, src_column, ref_column] = association;
+        const [, , AssociatedModel, src_column, ref_column, extraWhere] = association;
 
         // Générer le LEFT JOIN (pour préserver toutes les lignes, même celles avec NULL)
-        sql += `LEFT JOIN ${esc}${currentTableName}${esc} `;
-        sql += `ON ${esc}${currentTableName}${esc}.${esc}${ref_column}${esc} = ${esc}${prevTable}${esc}.${esc}${src_column}${esc} `;
+        let joinSql = `LEFT JOIN ${esc}${currentTableName}${esc} `;
+        joinSql += `ON ${esc}${currentTableName}${esc}.${esc}${ref_column}${esc} = ${esc}${prevTable}${esc}.${esc}${src_column}${esc}`;
+
+        // Ajouter les conditions extraWhere si présentes
+        if (extraWhere) {
+          _.forOwn(extraWhere, (value, key) => {
+            joinSql += ` AND ${esc}${currentTableName}${esc}.${esc}${key}${esc} = ${dialect.param(this.i++)}`;
+            params.push(value);
+          });
+        }
+
+        sql += joinSql + ' ';
 
         processedTables.add(currentTableName);
         prevTable = currentTableName;
       });
     });
 
+    // Retourner à la fois le SQL et les params pour qu'ils soient ajoutés
+    this._sortJoinParams = params;
     return sql;
   }
 
@@ -775,7 +794,7 @@ module.exports = class PaginatedOptimizedSql extends Sql {
     const { esc } = dialect;
 
     const { association, conditions, operator, children } = node;
-    const [, , AssociatedModel, src_column, ref_column] = association;
+    const [, , AssociatedModel, src_column, ref_column, extraWhere] = association;
     const joinTable = AssociatedModel.schema.table;
 
     // Ouvrir l'EXISTS
@@ -784,6 +803,14 @@ module.exports = class PaginatedOptimizedSql extends Sql {
     // Condition de jointure
     sql += `WHERE ${esc}${joinTable}${esc}.${esc}${ref_column}${esc} = ${esc}${parentTable}${esc}.${esc}${src_column}${esc} `;
 
+    // Ajouter les conditions extraWhere si présentes
+    if (extraWhere) {
+      _.forOwn(extraWhere, (value, key) => {
+        sql += `AND ${esc}${joinTable}${esc}.${esc}${key}${esc} = ${dialect.param(this.i++)} `;
+        params.push(value);
+      });
+    }
+
     // Ajouter les conditions de ce niveau (si présentes)
     if (conditions && !_.isEmpty(conditions)) {
       sql += this.buildConditions(conditions, joinTable, params, operator);
@@ -817,12 +844,20 @@ module.exports = class PaginatedOptimizedSql extends Sql {
     const { esc } = dialect;
 
     const { association, conditions, operator } = filterJoin;
-    const [, , AssociatedModel, src_column, ref_column] = association;
+    const [, , AssociatedModel, src_column, ref_column, extraWhere] = association;
     const joinTable = AssociatedModel.schema.table;
 
     let sql = `EXISTS (SELECT 1 FROM ${esc}${joinTable}${esc} `;
     sql += `WHERE ${esc}${joinTable}${esc}.${esc}${ref_column}${esc} = ${esc}${parentTable}${esc}.${esc}${src_column}${esc} `;
 
+    // Ajouter les conditions extraWhere si présentes
+    if (extraWhere) {
+      _.forOwn(extraWhere, (value, key) => {
+        sql += `AND ${esc}${joinTable}${esc}.${esc}${key}${esc} = ${dialect.param(this.i++)} `;
+        params.push(value);
+      });
+    }
+
     if (conditions && !_.isEmpty(conditions)) {
       sql += this.buildConditions(conditions, joinTable, params, operator);
     }
@@ -869,13 +904,21 @@ module.exports = class PaginatedOptimizedSql extends Sql {
         const association = this._findAssociationByPath(path, query.schema);
 
         if (association) {
-          const [, , AssociatedModel, src_column, ref_column] = association;
+          const [, , AssociatedModel, src_column, ref_column, extraWhere] = association;
           const joinTable = AssociatedModel.schema.table;
 
           // Construire l'EXISTS pour cette condition
           let existsSQL = `EXISTS (SELECT 1 FROM ${esc}${joinTable}${esc} `;
           existsSQL += `WHERE ${esc}${joinTable}${esc}.${esc}${ref_column}${esc} = ${esc}${parentTable}${esc}.${esc}${src_column}${esc} `;
 
+          // Ajouter les conditions extraWhere si présentes
+          if (extraWhere) {
+            _.forOwn(extraWhere, (ewValue, ewKey) => {
+              existsSQL += `AND ${esc}${joinTable}${esc}.${esc}${ewKey}${esc} = ${dialect.param(this.i++)} `;
+              params.push(ewValue);
+            });
+          }
+
           // Ajouter la condition sur la colonne
           const columnRef = `${esc}${joinTable}${esc}.${esc}${column}${esc}`;
 

package/src/Sql.js

@@ -58,7 +58,7 @@ module.exports = class Sql {
     sql += `FROM ${esc}${query.table}${esc} `;
 
     // joins
-    sql += this.addJoins();
+    sql += this.addJoins(params);
 
     // where
     sql += this.whereSQL(params);
@@ -101,7 +101,7 @@ module.exports = class Sql {
     sql += `FROM ${esc}${query.table}${esc} `;
 
     // joins
-    sql += this.addJoins();
+    sql += this.addJoins(params);
 
     // where
     sql += this.whereSQL(params);
@@ -118,17 +118,24 @@ module.exports = class Sql {
   };
 
   // JOINS
-  addJoins() {
+  addJoins(params) {
     const { query, dialect } = this;
     const { esc }   = dialect;
 
     let sql = '';
     _.each(query.joins, join => {
       const { src_schema, type, association, src_alias } = join;
-      const [ assoc_type, name, Obj, src_column, column] = association;
+      const [ assoc_type, name, Obj, src_column, column, extraWhere] = association;
       const src_table_alias = src_alias || src_schema.table;
       const table       = Obj.schema.table;
-      sql += `${type.toUpperCase()} JOIN ${esc}${table}${esc} AS ${esc}${name}${esc} ON ${esc}${name}${esc}.${esc}${column}${esc} = ${esc}${src_table_alias}${esc}.${esc}${src_column}${esc} `;
+      let joinSql = `${type.toUpperCase()} JOIN ${esc}${table}${esc} AS ${esc}${name}${esc} ON ${esc}${name}${esc}.${esc}${column}${esc} = ${esc}${src_table_alias}${esc}.${esc}${src_column}${esc}`;
+      if (extraWhere) {
+        _.forOwn(extraWhere, (value, key) => {
+          joinSql += ` AND ${esc}${name}${esc}.${esc}${key}${esc} = ${dialect.param(this.i++)}`;
+          params.push(value);
+        });
+      }
+      sql += joinSql + ' ';
     });
     return sql;
   }

package/test/JoinTest.js

@@ -202,6 +202,37 @@ describe('includes', () => {
       assert.strictEqual(foundBook.library.collection, library.collection);
       assert.strictEqual(foundBook.library.details.description, library.details.description);
     });
+
+    it('should apply extraWhere conditions on join', async () => {
+      class BookWithExtraWhere extends Model({
+        table: 'books',
+        primary: ['id'],
+        columns: [
+          'id',
+          'code',
+          'title',
+          'library_id',
+        ],
+        associations: () => ([
+          ['belongs_to', 'library', Library, 'library_id', 'id', { collection: 'A' }],
+        ])
+      }) {}
+
+      const libraryA = await Library.create({ title: 'Library A', collection: 'A' });
+      const libraryB = await Library.create({ title: 'Library B', collection: 'B' });
+      const bookA    = await BookWithExtraWhere.create({ library_id: libraryA.id });
+      const bookB    = await BookWithExtraWhere.create({ library_id: libraryB.id });
+
+      // Book A should have its library joined (collection = 'A' matches extraWhere)
+      const foundBookA = await BookWithExtraWhere.join('library').find(bookA.id);
+      assert.strictEqual(foundBookA.id, bookA.id);
+      assert.strictEqual(foundBookA.library.id, libraryA.id);
+
+      // Book B should NOT have its library joined (collection = 'B' does not match extraWhere)
+      const foundBookB = await BookWithExtraWhere.join('library').find(bookB.id);
+      assert.strictEqual(foundBookB.id, bookB.id);
+      assert.strictEqual(foundBookB.library, null);
+    });
   });
 
 });

package/test/PaginatedOptimizedQueryTest.js

@@ -1180,4 +1180,147 @@ describe('db.PaginatedOptimizedQuery', function() {
         'FULL phase should find block association for simple column name in direct associations');
     });
   });
+
+  //
+  describe('extraWhere support in PaginatedOptimizedQuery', function() {
+    // Modèle avec extraWhere sur l'association
+    class Library extends Model({
+      table: 'libraries',
+      primary: ['id'],
+      columns: {
+        id: 'integer',
+        title: 'string',
+        collection: 'string'
+      }
+    }) {}
+
+    class BookWithExtraWhere extends Model({
+      table: 'books',
+      primary: ['id'],
+      columns: {
+        id: 'integer',
+        code: 'string',
+        title: 'string',
+        library_id: 'integer'
+      },
+      associations: () => ([
+        ['belongs_to', 'library', Library, 'library_id', 'id', { collection: 'A' }]
+      ])
+    }) {}
+
+    it('should apply extraWhere in EXISTS clause for filterJoin', () => {
+      const query = mockGetDb(new PaginatedOptimizedQuery(BookWithExtraWhere));
+      query.query.verb = 'count';
+      query.where({
+        'library.title': 'Test%'
+      });
+
+      const sql = query.toSQL();
+
+      // Vérifier que EXISTS est présent
+      assert.ok(sql.sql.includes('EXISTS'), 'SQL should contain EXISTS');
+
+      // Vérifier que extraWhere est inclus dans la clause EXISTS
+      assert.ok(sql.sql.includes('`libraries`.`collection`'), 'SQL should include extraWhere column');
+      assert.ok(sql.params.includes('A'), 'SQL params should include extraWhere value');
+
+      // Le SQL devrait ressembler à :
+      // EXISTS (SELECT 1 FROM `libraries` WHERE `libraries`.`id` = `books`.`library_id` AND `libraries`.`collection` = ? AND `libraries`.`title` LIKE ?)
+    });
+
+    it('should apply extraWhere in LEFT JOIN for sorting', () => {
+      const query = mockGetDb(new PaginatedOptimizedQuery(BookWithExtraWhere));
+      query.query.verb = 'select_ids';
+      query
+        .where({ code: 'ABC' })
+        .order('library.title ASC')
+        .limit(50);
+
+      const sql = query.toSQL();
+
+      // Vérifier que LEFT JOIN est présent
+      assert.ok(sql.sql.includes('LEFT JOIN `libraries`'), 'SQL should contain LEFT JOIN');
+
+      // Vérifier que extraWhere est inclus dans la condition du JOIN
+      assert.ok(sql.sql.includes('`libraries`.`collection` = ?'), 'SQL should include extraWhere in JOIN condition');
+      assert.ok(sql.params.includes('A'), 'SQL params should include extraWhere value');
+
+      // Le SQL devrait ressembler à :
+      // LEFT JOIN `libraries` ON `libraries`.`id` = `books`.`library_id` AND `libraries`.`collection` = ?
+    });
+
+    it('should apply extraWhere in both EXISTS (filter) and LEFT JOIN (sort)', () => {
+      const query = mockGetDb(new PaginatedOptimizedQuery(BookWithExtraWhere));
+      query.query.verb = 'select_ids';
+      query
+        .where({
+          code: 'ABC',
+          'library.title': 'Test%'
+        })
+        .order('library.title ASC')
+        .limit(50);
+
+      const sql = query.toSQL();
+
+      // Vérifier que EXISTS et LEFT JOIN sont présents
+      assert.ok(sql.sql.includes('EXISTS'), 'SQL should contain EXISTS');
+      assert.ok(sql.sql.includes('LEFT JOIN'), 'SQL should contain LEFT JOIN');
+
+      // Vérifier que extraWhere apparaît 2 fois (une fois dans EXISTS, une fois dans JOIN)
+      const collectionMatches = sql.sql.match(/`libraries`\.`collection`/g) || [];
+      assert.strictEqual(collectionMatches.length, 2, 'extraWhere should appear twice (EXISTS + JOIN)');
+
+      // Vérifier que 'A' est dans les params deux fois
+      const aParams = sql.params.filter(p => p === 'A');
+      assert.strictEqual(aParams.length, 2, 'extraWhere value should appear twice in params');
+    });
+
+    it('should NOT include extraWhere in COUNT (no JOIN needed)', () => {
+      const query = mockGetDb(new PaginatedOptimizedQuery(BookWithExtraWhere));
+      query.query.verb = 'count';
+      query
+        .where({ code: 'ABC' })
+        .order('library.title ASC');  // ORDER BY ignored in COUNT
+
+      const sql = query.toSQL();
+
+      // COUNT ne devrait pas avoir de LEFT JOIN
+      assert.ok(!sql.sql.includes('LEFT JOIN'), 'COUNT should not have LEFT JOIN');
+
+      // COUNT ne devrait pas avoir de ORDER BY
+      assert.ok(!sql.sql.includes('ORDER BY'), 'COUNT should not have ORDER BY');
+
+      // Mais si on avait un filtre sur library, on aurait EXISTS avec extraWhere
+    });
+
+    // Test avec plusieurs conditions extraWhere
+    class BookWithMultipleExtraWhere extends Model({
+      table: 'books_multi',
+      primary: ['id'],
+      columns: {
+        id: 'integer',
+        title: 'string',
+        library_id: 'integer'
+      },
+      associations: () => ([
+        ['belongs_to', 'library', Library, 'library_id', 'id', { collection: 'A', title: 'Main' }]
+      ])
+    }) {}
+
+    it('should apply multiple extraWhere conditions', () => {
+      const query = mockGetDb(new PaginatedOptimizedQuery(BookWithMultipleExtraWhere));
+      query.query.verb = 'count';
+      query.where({
+        'library.title': 'Test%'
+      });
+
+      const sql = query.toSQL();
+
+      // Vérifier que les deux conditions extraWhere sont présentes
+      assert.ok(sql.sql.includes('`libraries`.`collection`'), 'SQL should include collection extraWhere');
+      assert.ok(sql.sql.includes('`libraries`.`title`'), 'SQL should include title in filter condition');
+      assert.ok(sql.params.includes('A'), 'SQL params should include collection value');
+      assert.ok(sql.params.includes('Main'), 'SQL params should include title extraWhere value');
+    });
+  });
 });