@igojs/db 6.0.0-beta.1

package/test/AssociationsTest.js

@@ -0,0 +1,301 @@
+require('./init');
+const assert = require('assert');
+const Model = require('@igojs/db').Model;
+
+describe('includes', () => {
+
+  class Library extends Model({
+    table: 'libraries',
+    primary: ['id'],
+    columns: [
+      'id',
+      'title'
+    ],
+    associations: () => ([
+      ['has_many', 'books', Book, 'id', 'library_id'],
+    ])
+  }) {}
+
+  class Book extends Model({
+    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'],
+    ])
+  }) {}
+
+  describe('belongs_to', () => {
+
+    it('should find a book with its library', async () => {
+      const library = await Library.create();
+      const book = await Book.create({ library_id: library.id });
+      const foundBook = await Book.includes('library').find({id: book.id});
+      assert(foundBook.library);
+      assert.strictEqual(foundBook.library.id, library.id);
+    });
+
+    it('should set association to null if wrong id', async () => {
+      await Library.create();
+      const book = await Book.create({ library_id: 99999 });
+      const foundBook = await Book.includes('library').find(book.id);
+      assert.strictEqual(foundBook.library, null);
+    });
+
+    it('should list books with their libraries', async () => {
+      const library = await Library.create();
+      const library2 = await Library.create();
+      await Book.create({ library_id: library.id });
+      await Book.create({ library_id: library2.id });
+      const books = await Book.includes('library').list();
+      assert.strictEqual(books.length, 2);
+      assert.strictEqual(books[0].library.id, library.id);
+      assert.strictEqual(books[1].library.id, library2.id);
+    });
+  });
+
+  describe('has_many', () => {
+
+    const schema = {
+      table: 'libraries',
+      primary: ['id'],
+      columns: ['id', 'title'],
+      associations: () => [
+        ['has_many', 'books', Book, 'id', 'library_id'],
+      ]
+    };
+    class Library extends Model(schema) {}
+
+    it('should find a library with its books', async () => {
+      const library = await Library.create();
+      await Book.create({ library_id: library.id });
+      await Book.create({ library_id: library.id });
+      const foundLibrary = await Library.includes('books').find(library.id);
+      assert.strictEqual(foundLibrary.books.length, 2);
+    });
+
+    it('should return an empty array if ref null', async () => {
+      const library = await Library.create();
+      await Book.create({ library_id: null });
+      const foundLibrary = await Library.includes('books').find(library.id);
+      assert(Array.isArray(foundLibrary.books));
+      assert.strictEqual(foundLibrary.books.length, 0);
+    });
+
+    it('should return an empty array if wrong id', async () => {
+      const library = await Library.create();
+      await Book.create({ library_id: 99999 });
+      const foundLibrary = await Library.includes('books').find(library.id);
+      assert(Array.isArray(foundLibrary.books));
+      assert.strictEqual(foundLibrary.books.length, 0);
+    });
+
+    it('should list libraries with their books', async () => {
+      const library = await Library.create();
+      const library2 = await Library.create();
+      await Book.create({ library_id: library.id });
+      await Book.create({ library_id: library.id });
+      await Book.create({ library_id: library2.id });
+      const libraries = await Library.includes('books').list();
+      assert.strictEqual(libraries[0].books.length, 2);
+      assert.strictEqual(libraries[1].books.length, 1);
+    });
+
+    it('should handle default [] values correctly', async () => {
+      await Library.create();
+      await Library.create();
+      const libraries = await Library.includes('books').list();
+      libraries[0].books.push({ hello: 'world' });
+      assert.strictEqual(libraries[0].books.length, 1);
+      assert.strictEqual(libraries[1].books.length, 0);
+    });
+
+    schema.scopes = {
+      default: q => q.includes('books')
+    };
+    class Library2 extends Model(schema) {}
+
+    // it.only('should ignore associations for inserts', async () => {
+    //   const err = await Library2.create();
+    //   assert(!err);
+    // });
+
+    it('should ignore associations for updates', async () => {
+      const library = await Library2.create();
+      assert(library);
+    });
+  });
+
+  describe('has_many from array', () => {
+
+    const schema = {
+      table: 'libraries',
+      primary: ['id'],
+      columns: [
+        'id',
+        'title',
+        { name: 'books_ids_json', type: 'json', attr: 'books_ids' },
+      ],
+      associations: () => [
+        ['has_many', 'books', Book, 'books_ids', 'id'],
+      ]
+    };
+    class Library extends Model(schema) {}
+
+    it('should find a library with its books', async () => {
+      const book1 = await Book.create();
+      const book2 = await Book.create();
+      const library = await Library.create({ books_ids: [book1.id, book2.id] });
+      const foundLibrary = await Library.includes('books').find(library.id);
+      assert.strictEqual(foundLibrary.books.length, 2);
+      assert.strictEqual(foundLibrary.books[0].id, book1.id);
+    });
+
+    it('should return an empty array if ref null', async () => {
+      const book1 = await Book.create();
+      const book2 = await Book.create();
+      const library = await Library.create({ books_ids: null });
+      const foundLibrary = await Library.includes('books').find(library.id);
+      assert(Array.isArray(foundLibrary.books));
+      assert.strictEqual(foundLibrary.books.length, 0);
+    });
+
+    it('should return an empty array if wrong id', async () => {
+      const book1 = await Book.create();
+      const book2 = await Book.create();
+      const library = await Library.create({ books_ids: [99999] });
+      const foundLibrary = await Library.includes('books').find(library.id);
+      assert(Array.isArray(foundLibrary.books));
+      assert.strictEqual(foundLibrary.books.length, 0);
+    });
+
+    it('should list libraries with their books (2)', async () => {
+      const book1 = await Book.create();
+      const book2 = await Book.create();
+      const book3 = await Book.create();
+      await Library.create({ books_ids: [book1.id] });
+      await Library.create({ books_ids: [book1.id, book2.id, book3.id] });
+      const libraries = await Library.includes('books').list();
+      assert.strictEqual(libraries[0].books.length, 1);
+      assert.strictEqual(libraries[1].books.length, 3);
+    });
+
+    it('should include associations on reload', async () => {
+      const library = await Library.create();
+      const book = await Book.create({ library_id: library.id });
+      const reloadedBook = await book.reload('library');
+      assert.strictEqual(reloadedBook.library.id, library.id);
+    });
+  });
+
+  describe('scopes', () => {
+
+    it('should merge default scope with string include', async () => {
+      class Library2 extends Model({
+        table: 'libraries',
+        primary: ['id'],
+        columns: [
+          'id',
+          'title'
+        ],
+        associations: () => ([
+          ['has_many', 'books', Book, 'id', 'library_id'],
+        ]),
+        scopes: {
+          default: q => q.includes('books')
+        }
+      }) {}
+
+      const library = await Library2.create();
+      await Book.create({ library_id: library.id });
+      const libraries = await Library2.includes({ books: 'library' }).list();
+      assert.strictEqual(libraries.length, 1);
+      assert.strictEqual(libraries[0].books.length, 1);
+      assert.strictEqual(libraries[0].books[0].library.id, library.id);
+    });
+
+    it('should merge default scope with object include', async () => {
+      class Library2 extends Model({
+        table: 'libraries',
+        primary: ['id'],
+        columns: [
+          'id',
+          'title'
+        ],
+        associations: () => ([
+          ['has_many', 'books', Book, 'id', 'library_id'],
+        ]),
+        scopes: {
+          default: q => q.includes({ books: 'library' })
+        }
+      }) {}
+
+      const library = await Library2.create();
+      await Book.create({ library_id: library.id });
+      const libraries = await Library2.includes('books').list();
+      assert.strictEqual(libraries.length, 1);
+      assert.strictEqual(libraries[0].books.length, 1);
+      assert.strictEqual(libraries[0].books[0].library.id, library.id);
+    });
+
+    it('should override default scope with 2-levels object includes', async () => {
+      class Library2 extends Model({
+        table: 'libraries',
+        primary: ['id'],
+        columns: [
+          'id',
+          'title'
+        ],
+        associations: () => ([
+          ['has_many', 'books', Book, 'id', 'library_id'],
+        ]),
+        scopes: {
+          default: q => q.includes({ books: 'library' })
+        }
+      }) {}
+
+      const library = await Library2.create();
+      await Book.create({ library_id: library.id });
+      const libraries = await Library2.includes({ books: { library: 'books' } }).list();
+      assert.strictEqual(libraries.length, 1);
+      assert.strictEqual(libraries[0].books.length, 1);
+      assert.strictEqual(libraries[0].books[0].library.id, library.id);
+      assert.strictEqual(libraries[0].books[0].library.books.length, 1);
+    });
+
+    it('should override default scope with 4-levels object includes', async () => {
+      class Library2 extends Model({
+        table: 'libraries',
+        primary: ['id'],
+        columns: [
+          'id',
+          'title'
+        ],
+        associations: () => ([
+          ['has_many', 'books', Book, 'id', 'library_id'],
+        ]),
+        scopes: {
+          default: q => q.includes({ books: { library: { books: 'library' } } })
+        }
+      }) {}
+
+      const library = await Library2.create();
+      await Book.create({ library_id: library.id });
+      const libraries = await Library2.includes({ books: 'library' }).list();
+      assert.strictEqual(libraries.length, 1);
+      assert.strictEqual(libraries[0].books.length, 1);
+      assert.strictEqual(libraries[0].books[0].library.id, library.id);
+      assert.strictEqual(libraries[0].books[0].library.books.length, 1);
+      assert.strictEqual(libraries[0].books[0].library.books[0].library.id, library.id);
+    });
+  });
+
+});

package/test/CacheStatsTest.js

@@ -0,0 +1,40 @@
+
+
+require('./init');
+
+const assert    = require('assert');
+
+const Model       = require('@igojs/db').Model;
+const CacheStats  = require('@igojs/db').CacheStats;
+
+//
+describe('db.CacheStats', function() {
+
+  class Book extends Model({
+    table:    'books',
+    primary:  ['id'],
+    columns: [
+      'id',
+      'code',
+      'title',
+      'created_at'
+    ],
+    cache: {
+      ttl: 100
+    }
+  }) {}
+
+  //
+  describe('getStats', function() {
+  
+    it('should save stats in cache', async () => {
+      const book1 = await Book.create();
+      await Book.find(book1.id);
+      const stats = await CacheStats.getStats();
+      assert.strictEqual(stats.length, 1);
+      assert.strictEqual(stats[0].hits, 1);
+      assert.strictEqual(stats[0].total, 2);
+      assert.strictEqual(stats[0].table, 'books');
+    });
+  });
+});

package/test/CachedQueryTest.js

@@ -0,0 +1,49 @@
+require('./init');
+
+const assert = require('assert');
+const Model  = require('@igojs/db').Model;
+const cache  = require('@igojs/server').cache;
+
+describe('db.CachedQuery', function () {
+
+  class Book extends Model({
+    table:   'books',
+    primary: ['id'],
+    columns: [
+      'id',
+      'code',
+      'title',
+      'created_at'
+    ],
+    cache: {
+      ttl: 100
+    }
+  }) {}
+
+  describe('find', function () {
+
+    const key = id => '{"sql":"SELECT `books`.* FROM `books` WHERE `books`.`id` = ? ORDER BY `books`.`id` ASC LIMIT ?, ?","params":[' + id + ',0,1]}';
+
+    it('should put rows in cache', async () => {
+      const book1 = await Book.create();
+      const book  = await Book.find(book1.id);
+
+      assert.strictEqual(book.id, book1.id);
+
+      const rows = await cache.get('_cached.books', key(book1.id));
+      assert.ok(rows, 'Expected cached rows to exist');
+      assert.strictEqual(rows.length, 1);
+      assert.strictEqual(rows[0].id, book.id);
+    });
+
+    it('should clear cache after update', async function () {
+      const book1 = await Book.create();
+      await book1.update({ title: 'abc' });
+
+      const rows = await cache.get('_cached.books', key(book1.id));
+      assert.strictEqual(rows, null, 'Expected cache to be cleared after update');
+    });
+
+  });
+
+});

package/test/JoinTest.js

@@ -0,0 +1,207 @@
+require('./init');
+const assert = require('assert');
+const Model = require('@igojs/db').Model;
+
+describe('includes', () => {
+
+  class Country extends Model({
+    table: 'countries',
+    primary: ['id'],
+    columns: [
+      'id',
+      'name',
+    ],
+    associations: () => ([
+      ['has_many', 'cities', City, 'id', 'country_id'],
+    ])
+  }) {}
+
+  class City extends Model({
+    table: 'cities',
+    primary: ['id'],
+    columns: [
+      'id',
+      'name',
+      'country_id',
+    ],
+    associations: () => ([
+      ['has_many', 'libraries', Library, 'id', 'city_id'],
+      ['belongs_to', 'country', Country, 'country_id', 'id'],
+    ])
+  }) {}
+
+  class Library extends Model({
+    table: 'libraries',
+    primary: ['id'],
+    columns: [
+      'id',
+      'title',
+      'collection',
+      'city_id',
+      { name: 'details_json', type: 'json', attr: 'details' },
+    ],
+    associations: () => ([
+      ['has_many', 'books', Book, 'id', 'library_id'],
+      ['belongs_to', 'city', City, 'city_id', 'id'],
+    ]),
+    scopes: {
+      default: query => query.includes('city')
+    }
+  }) {}
+
+  class Book extends Model({
+    table: 'books',
+    primary: ['id'],
+    columns: [
+      'id',
+      'code',
+      'title',
+      { name: 'details_json', type: 'json', attr: 'details' },
+      { name: 'is_available', type: 'boolean' },
+      'library_id',
+      'original_library_id',
+      'created_at'
+    ],
+    associations: () => ([
+      ['belongs_to', 'library', Library, 'library_id', 'id'],
+      ['belongs_to', 'original_library', Library, 'original_library_id', 'id'],
+    ])
+  }) {}
+
+  describe('join', () => {
+    it('should load a book join with its library collection', async () => {
+      const library   = await Library.create({ title: 'the big library', collection: 'A' });
+      const book      = await Book.create({ library_id: library.id });
+
+      const foundBook = await Book.join('library').find(book.id);
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.collection, library.collection);
+    });
+
+    it('should load a book join with its library collection with custom select', async () => {
+      const library = await Library.create({ title: 'A' });
+      const book = await Book.create({ library_id: library.id });
+      const foundBook = await Book
+      .select('`books`.`id`, `libraries`.`title` AS library_title')
+      .join('library')
+      .find(book.id);
+      assert.strictEqual(foundBook.library_title, library.title);
+    });
+
+    it('should load a book join with specified columns, and a filter', async () => {
+      const library = await Library.create({ title: 'A' });
+      const book = await Book.create({ library_id: library.id });
+      const foundBook = await Book.join('library', ['title'])
+      .where({ 'library.title': library.title })
+      .find(book.id);
+      assert.strictEqual(foundBook.library.title, library.title);
+    });
+
+    // count with join
+    it('should count books with join and where condition', async () => {
+      const libraryA = await Library.create({ title: 'A' });
+      const libraryB = await Library.create({ title: 'B' });
+      await Book.create({ library_id: libraryA.id });
+      await Book.create({ library_id: libraryA.id });
+      await Book.create({ library_id: libraryB.id });
+
+      const count = await Book.join('library').where('`library`.`title` = \'B\'').count();
+
+      assert.strictEqual(count, 1);
+    });
+
+    // cascade joins
+    it('should load books with libraries and cities', async () => {
+      const city      = await City.create({ name: 'Paris' });
+      const library   = await Library.create({ title: 'A', city_id: city.id });
+      await Book.create({ library_id: library.id });
+      await Book.create({ library_id: library.id });
+
+      const books = await Book.join({library: 'city'}).list();
+
+      assert.strictEqual(books.length, 2);
+      assert.strictEqual(books[0].library.city.id, city.id);
+    });
+
+    it('should load a book even if no library', async () => {
+      const book = await Book.create({});
+      const foundBook = await Book.join('library').find(book.id);
+      assert(foundBook);
+      assert.strictEqual(foundBook.library, null);
+    });    
+
+    it('should load a book with a double join', async () => {
+      const library         = await Library.create({ title: 'the big library' });
+      const originalLibrary = await Library.create({ title: 'the original one' });
+      const book            = await Book.create({ library_id: library.id, original_library_id: originalLibrary.id });
+
+      const foundBook = await Book.join(['library', 'original_library']).find(book.id);
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.title, library.title);
+      assert.strictEqual(foundBook.original_library.title, originalLibrary.title);
+    });
+
+    it('should load a book with a three-level join', async () => {
+      const country = await Country.create({ name: 'France' });
+      const city    = await City.create({ name: 'Paris', country_id: country.id });
+      const library = await Library.create({ title: 'the big library', city_id: city.id });
+      const book    = await Book.create({ library_id: library.id });
+
+      const foundBook = await Book.join({ library: { city: 'country' } }).find(book.id);
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.city.country.name, country.name);
+    });
+
+    it('should load a book and its library with includes city', async () => {
+      const city    = await City.create({ name: 'London' });
+      const library = await Library.create({ title: 'London Library', city_id: city.id });
+      const book    = await Book.create({ library_id: library.id });
+
+      const foundBook = await Book.join('library').includes('library.city').find(book.id);
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.city.name, city.name);
+    });
+
+    it('should load a book and its library with its books', async () => {
+      const library = await Library.create({ title: 'London Library' });
+      const book    = await Book.create({ library_id: library.id });
+      const book2   = await Book.create({ library_id: library.id });
+
+      const foundBook = await Book.join('library').includes('library.books').find(book.id);
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.books.length, 2);
+      assert.strictEqual(foundBook.library.books[0].id, book.id);
+      assert.strictEqual(foundBook.library.books[1].id, book2.id);
+    });
+
+    it('should load a book and the city\'s libraries (nested includes)', async () => {
+      const country = await Country.create({ name: 'France' });
+      const city = await City.create({ name: 'Paris', country_id: country.id });
+      const library1 = await Library.create({ title: 'Paris Library 1', city_id: city.id });
+      const library2 = await Library.create({ title: 'Paris Library 2', city_id: city.id });
+      await Library.create({ title: 'Other Library', city_id: null }); // Not associated with Paris
+      const book = await Book.create({ library_id: library1.id });
+
+      const foundBook = await Book.join({library: 'city'}).includes('library.city.libraries').find(book.id);
+
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.id, library1.id);
+      assert.strictEqual(foundBook.library.city.id, city.id);
+      assert(Array.isArray(foundBook.library.city.libraries));
+      assert.strictEqual(foundBook.library.city.libraries.length, 2);
+      assert.strictEqual(foundBook.library.city.libraries[0].id, library1.id);
+      assert.strictEqual(foundBook.library.city.libraries[1].id, library2.id);
+    });
+
+    it('should load a book join with its library and details', async () => {
+      const library   = await Library.create({ title: 'the big library', collection: 'A', details: { description: 'A big library' } });
+      const book      = await Book.create({ library_id: library.id });
+
+      const foundBook = await Book.join('library').find(book.id);
+      assert.strictEqual(foundBook.id, book.id);
+      assert.strictEqual(foundBook.library.collection, library.collection);
+      assert.strictEqual(foundBook.library.details.description, library.details.description);
+    });
+  });
+
+});