@igojs/db 6.0.0-beta.7 → 6.0.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igojs/db",
-  "version": "6.0.0-beta.7",
+  "version": "6.0.0-beta.8",
   "description": "Igo ORM - Database abstraction layer for MySQL and PostgreSQL",
   "main": "index.js",
   "scripts": {

package/src/Model.js

@@ -40,7 +40,7 @@ module.exports = function(schema) {
       await this.beforeUpdate(values);
 
       await newQuery(this.constructor, 'update')
-      .unscoped()
+      .unscope()
       .values(values)
       .where(this.primaryObject())
       .execute();
@@ -56,14 +56,14 @@ module.exports = function(schema) {
 
     // reload
     async reload(includes) {
-      const query = this.constructor.unscoped();
+      const query = this.constructor.unscope();
       includes && query.includes(includes);
       return await query.find(this.id);
     }
 
     // delete
     delete() {
-      return newQuery(this.constructor, 'delete').unscoped().where(this.primaryObject()).execute();
+      return newQuery(this.constructor, 'delete').unscope().where(this.primaryObject()).execute();
     }
 
     async beforeCreate() { }
@@ -101,9 +101,9 @@ module.exports = function(schema) {
 
         const { insertId } = result;
         if (insertId) {
-          return _this.unscoped().find(insertId);
+          return _this.unscope().find(insertId);
         }
-        return _this.unscoped().find(obj.primaryObject());
+        return _this.unscope().find(obj.primaryObject());
       };
 
       return await create();
@@ -177,12 +177,12 @@ module.exports = function(schema) {
 
     // delete
     static delete(id, ) {
-      return newQuery(this, 'delete').unscoped().where({ id: id }).execute();
+      return newQuery(this, 'delete').unscope().where({ id: id }).execute();
     }
 
     // delete all
     static async deleteAll() {
-      return newQuery(this, 'delete').unscoped().execute();
+      return newQuery(this, 'delete').unscope().execute();
     }
 
     // destroy all
@@ -193,7 +193,7 @@ module.exports = function(schema) {
     //
     static update(values, ) {
       values.updated_at = new Date();
-      return newQuery(this).unscoped().update(values, );
+      return newQuery(this).unscope().update(values, );
     }
 
     // includes
@@ -214,9 +214,15 @@ module.exports = function(schema) {
       console.warn('Invalid join argument for Model.join(). Must be a string, array, or object.');
     }
 
-    //unscoped
+    // unscoped (deprecated, use unscope())
     static unscoped() {
-      return newQuery(this).unscoped();
+      console.warn('Model.unscoped() is deprecated, use unscope() instead.');
+      return this.unscope();
+    }
+
+    // unscope
+    static unscope(...clauses) {
+      return newQuery(this).unscope(...clauses);
     }
 
     //scope

package/src/PaginatedOptimizedQuery.js

@@ -402,6 +402,10 @@ module.exports = class PaginatedOptimizedQuery extends Query {
     fullQuery.query = _.cloneDeep(this.query);
     fullQuery.query.verb = 'select';
 
+    // Restaurer les joins originaux : _.cloneDeep crée de nouveaux objets pour src_schema,
+    // ce qui casse les lookups par identité (===) dans le Map de Query.execute()
+    fullQuery.query.joins = this.query.joins;
+
     // Conserver uniquement les "vrais" joins (pas les filterJoins)
     // Les filterJoins ne sont utilisés que pour COUNT et IDS
     fullQuery.query.filterJoins = [];

package/src/Query.js

@@ -50,7 +50,8 @@ module.exports = class Query {
       group:    null,
       includes: {},
       options:  {},
-      scopes:   [ 'default' ]
+      scopes:   [ 'default' ],
+      unscopes: []
     };
 
     // filter on subclass
@@ -153,9 +154,19 @@ module.exports = class Query {
     return this;
   }
 
-  // UNSCOPED
+  // UNSCOPED (deprecated, use unscope())
   unscoped() {
-    this.query.scopes.length = 0;
+    console.warn('Query.unscoped() is deprecated, use unscope() instead.');
+    return this.unscope();
+  }
+
+  // UNSCOPE
+  unscope(...clauses) {
+    if (clauses.length === 0) {
+      this.query.scopes.length = 0;
+    } else {
+      this.query.unscopes.push(...clauses);
+    }
     return this;
   }
 
@@ -265,6 +276,21 @@ module.exports = class Query {
       }
       schema.scopes[scope](this);
     });
+    // Apply unscopes after scopes
+    for (const clause of query.unscopes) {
+      switch (clause) {
+        case 'where':    query.where = [];    break;
+        case 'whereNot': query.whereNot = []; break;
+        case 'order':    query.order = [];    break;
+        case 'includes': query.includes = {}; break;
+        case 'joins':    query.joins = [];    break;
+        case 'select':   query.select = null; break;
+        case 'distinct': query.distinct = null; break;
+        case 'group':    query.group = null;  break;
+        case 'limit':    delete query.limit;  break;
+        case 'offset':   delete query.offset; break;
+      }
+    }
   }
 
   // INCLUDES

package/test/JoinTest.js

@@ -235,4 +235,38 @@ describe('includes', () => {
     });
   });
 
+  describe('paginatedOptimized join', () => {
+    it('should attach joined data in selectFull phase (cloneDeep regression)', async () => {
+      const city    = await City.create({ name: 'Paris' });
+      const library = await Library.create({ title: 'BNF', city_id: city.id });
+      const book    = await Book.create({ library_id: library.id });
+
+      const books = await Book.paginatedOptimized()
+        .join('library')
+        .limit(10)
+        .list();
+
+      assert.strictEqual(books.length, 1);
+      assert.strictEqual(books[0].id, book.id);
+      assert.strictEqual(books[0].library.id, library.id);
+      assert.strictEqual(books[0].library.title, 'BNF');
+    });
+
+    it('should attach nested joined data in selectFull phase', async () => {
+      const city    = await City.create({ name: 'Lyon' });
+      const library = await Library.create({ title: 'Municipale', city_id: city.id });
+      const book    = await Book.create({ library_id: library.id });
+
+      const books = await Book.paginatedOptimized()
+        .join({ library: 'city' })
+        .limit(10)
+        .list();
+
+      assert.strictEqual(books.length, 1);
+      assert.strictEqual(books[0].library.id, library.id);
+      assert.strictEqual(books[0].library.city.id, city.id);
+      assert.strictEqual(books[0].library.city.name, 'Lyon');
+    });
+  });
+
 });

package/test/ModelTest.js

@@ -182,7 +182,7 @@ describe('db.Model', () => {
         const first   = await Book.create();
         const hibook  = await Book.create({title: 'hi'});
         await Book.create();
-        const book = await Book.unscoped().first();
+        const book = await Book.unscope().first();
         assert.strictEqual(first.id, book.id);
         assert.strictEqual('hi', hibook.title);
       });
@@ -203,7 +203,7 @@ describe('db.Model', () => {
         await Book.create();
         await Book.create();
         const last = await Book.create();
-        const book = await Book.unscoped().last();
+        const book = await Book.unscope().last();
         assert.strictEqual(last.id, book.id);
       });
     });
@@ -374,11 +374,91 @@ describe('db.Model', () => {
     it('should use a scope', async () => {
       await BookWithScopes.create({code: 'a'});
       await BookWithScopes.create({code: 'abc'});
-      const books = await BookWithScopes.unscoped().scope('a').list();
+      const books = await BookWithScopes.unscope().scope('a').list();
       assert.strictEqual(books.length, 1);
     });
   });
 
+  describe('unscope', () => {
+
+    class Library extends Model({
+      table:    'libraries',
+      primary:  ['id'],
+      columns:  ['id', 'title'],
+    }) {}
+
+    const scopedSchema = {
+      table:    'books',
+      primary:  ['id'],
+      columns: [
+        'id',
+        'code',
+        'title',
+        {name: 'details_json', type: 'json', attr: 'details'},
+        {name:'is_available', type: 'boolean'},
+        'library_id',
+        'created_at'
+      ],
+      associations: () => ([
+        ['belongs_to', 'library', Library, 'library_id', 'id'],
+      ]),
+      scopes: {
+        default:  query => query.where({ code: 'abc' }).order('`created_at` DESC').includes('library'),
+        active:   query => query.where({ is_available: true }),
+      }
+    };
+
+    class ScopedBook extends Model(scopedSchema) {}
+
+    it('unscope() without args should remove all scopes', async () => {
+      await ScopedBook.create({ code: 'a' });
+      await ScopedBook.create({ code: 'abc' });
+      const books = await ScopedBook.unscope().list();
+      assert.strictEqual(books.length, 2);
+    });
+
+    it('unscope("where") should remove where added by scope', async () => {
+      await ScopedBook.create({ code: 'a' });
+      await ScopedBook.create({ code: 'abc' });
+      const books = await ScopedBook.unscope('where').list();
+      assert.strictEqual(books.length, 2);
+    });
+
+    it('unscope("includes") should remove includes added by scope', async () => {
+      const library = await Library.create({ title: 'Main' });
+      await ScopedBook.create({ code: 'abc', library_id: library.id });
+      const books = await ScopedBook.unscope('includes').list();
+      assert.strictEqual(books.length, 1);
+      assert.strictEqual(books[0].library, undefined);
+    });
+
+    it('unscope("order") should remove order added by scope', async () => {
+      const b1 = await ScopedBook.create({ code: 'abc' });
+      const b2 = await ScopedBook.create({ code: 'abc' });
+      const books = await ScopedBook.unscope('order').list();
+      // without DESC order, should be ASC (default)
+      assert(books[0].id <= books[1].id);
+    });
+
+    it('unscope("where", "order") should remove both', async () => {
+      await ScopedBook.create({ code: 'a' });
+      const b2 = await ScopedBook.create({ code: 'abc' });
+      const books = await ScopedBook.unscope('where', 'order').list();
+      assert.strictEqual(books.length, 2);
+      assert(books[0].id <= books[1].id);
+    });
+
+    it('should work with chaining: unscope("includes").scope("active")', async () => {
+      const library = await Library.create({ title: 'Main' });
+      await ScopedBook.create({ code: 'abc', is_available: true, library_id: library.id });
+      await ScopedBook.create({ code: 'abc', is_available: false, library_id: library.id });
+      const books = await ScopedBook.unscope('includes').scope('active').list();
+      assert.strictEqual(books.length, 1);
+      assert.strictEqual(books[0].is_available, true);
+      assert.strictEqual(books[0].library, undefined);
+    });
+  });
+
   describe('count', () => {
     it('should count rows', async () => {
       for (let n = 0; n < 10; n++) {