@simonbackx/simple-database 1.25.0 → 1.26.0

package/dist/src/classes/Model.test.js

@@ -7,31 +7,31 @@ const ManyToManyRelation_1 = require("./ManyToManyRelation");
 const ManyToOneRelation_1 = require("./ManyToOneRelation");
 const Model_1 = require("./Model");
 const OneToManyRelation_1 = require("./OneToManyRelation");
-describe("Model", () => {
+describe('Model', () => {
     class TestDecoder {
         constructor(id) {
             this.id = id;
         }
-        encode(context) {
+        encode(_) {
             return {
                 id: this.id,
             };
         }
         static decode(data) {
-            return new TestDecoder(data.field("id").number);
+            return new TestDecoder(data.field('id').number);
         }
     }
     class TestModelFriend extends Model_1.Model {
     }
-    TestModelFriend.table = "_testModels_testModels";
+    TestModelFriend.table = '_testModels_testModels';
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "integer" })
+        (0, Column_1.column)({ type: 'integer' })
     ], TestModelFriend.prototype, "testModelsIdA", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "integer" })
+        (0, Column_1.column)({ type: 'integer' })
     ], TestModelFriend.prototype, "testModelsIdB", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "integer" })
+        (0, Column_1.column)({ type: 'integer' })
     ], TestModelFriend.prototype, "priority", void 0);
     // Create a new class
     class TestModel extends Model_1.Model {
@@ -43,27 +43,27 @@ describe("Model", () => {
             this.parentId = null; // null = no address
         }
     }
-    TestModel.table = "testModels";
-    TestModel.parent = new ManyToOneRelation_1.ManyToOneRelation(TestModel, "parent");
-    TestModel.friends = new ManyToManyRelation_1.ManyToManyRelation(TestModel, TestModel, "friends", TestModelFriend);
-    TestModel.sortedFriends = new ManyToManyRelation_1.ManyToManyRelation(TestModel, TestModel, "sortedFriends").setSort("priority");
-    TestModel.children = new OneToManyRelation_1.OneToManyRelation(TestModel, TestModel, "children", "parentId");
-    TestModel.sortedChildren = new OneToManyRelation_1.OneToManyRelation(TestModel, TestModel, "sortedChildren", "parentId").setSort("count");
+    TestModel.table = 'testModels';
+    TestModel.parent = new ManyToOneRelation_1.ManyToOneRelation(TestModel, 'parent');
+    TestModel.friends = new ManyToManyRelation_1.ManyToManyRelation(TestModel, TestModel, 'friends', TestModelFriend);
+    TestModel.sortedFriends = new ManyToManyRelation_1.ManyToManyRelation(TestModel, TestModel, 'sortedFriends').setSort('priority');
+    TestModel.children = new OneToManyRelation_1.OneToManyRelation(TestModel, TestModel, 'children', 'parentId');
+    TestModel.sortedChildren = new OneToManyRelation_1.OneToManyRelation(TestModel, TestModel, 'sortedChildren', 'parentId').setSort('count');
     tslib_1.__decorate([
-        (0, Column_1.column)({ primary: true, type: "integer" })
+        (0, Column_1.column)({ primary: true, type: 'integer' })
     ], TestModel.prototype, "id", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "string" })
+        (0, Column_1.column)({ type: 'string' })
     ], TestModel.prototype, "name", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "integer" })
+        (0, Column_1.column)({ type: 'integer' })
     ], TestModel.prototype, "count", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "boolean" })
+        (0, Column_1.column)({ type: 'boolean' })
     ], TestModel.prototype, "isActive", void 0);
     tslib_1.__decorate([
         (0, Column_1.column)({
-            type: "datetime",
+            type: 'datetime',
             beforeSave: (old) => {
                 if (old === undefined) {
                     const date = new Date();
@@ -75,13 +75,13 @@ describe("Model", () => {
         })
     ], TestModel.prototype, "createdOn", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "date", nullable: true })
+        (0, Column_1.column)({ type: 'date', nullable: true })
     ], TestModel.prototype, "birthDay", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "json", decoder: TestDecoder })
+        (0, Column_1.column)({ type: 'json', decoder: TestDecoder })
     ], TestModel.prototype, "testDecoder", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ foreignKey: TestModel.parent, type: "integer", nullable: true })
+        (0, Column_1.column)({ foreignKey: TestModel.parent, type: 'integer', nullable: true })
     ], TestModel.prototype, "parentId", void 0);
     // Create a new class
     class Dog extends Model_1.Model {
@@ -90,31 +90,31 @@ describe("Model", () => {
             this.id = null;
         }
     }
-    Dog.table = "dogs";
+    Dog.table = 'dogs';
     tslib_1.__decorate([
-        (0, Column_1.column)({ primary: true, type: "integer" })
+        (0, Column_1.column)({ primary: true, type: 'integer' })
     ], Dog.prototype, "id", void 0);
     tslib_1.__decorate([
-        (0, Column_1.column)({ type: "string" })
+        (0, Column_1.column)({ type: 'string' })
     ], Dog.prototype, "name", void 0);
     tslib_1.__decorate([
         (0, Column_1.column)({
-            type: "datetime",
-            skipUpdate: true
+            type: 'datetime',
+            skipUpdate: true,
         })
     ], Dog.prototype, "updatedAt", void 0);
-    test("Not possible to choose own primary key for integer type primary", async () => {
+    test('Not possible to choose own primary key for integer type primary', async () => {
         const m = new TestModel();
         m.id = 123;
-        m.name = "My name";
+        m.name = 'My name';
         m.count = 1;
         m.isActive = true;
         m.birthDay = new Date(1990, 0, 1);
         await expect(m.save()).rejects.toThrow(/primary/i);
     });
-    test("Before save test", async () => {
+    test('Before save test', async () => {
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.birthDay = new Date(1990, 0, 1);
@@ -125,11 +125,11 @@ describe("Model", () => {
         await m.save();
         expect(m.createdOn).toBe(date);
     });
-    test("Skip update fields", async () => {
+    test('Skip update fields', async () => {
         const now = new Date();
         now.setMilliseconds(0);
         const dog = new Dog();
-        dog.name = "My dog";
+        dog.name = 'My dog';
         dog.updatedAt = now;
         await expect(dog.save()).resolves.toEqual(true);
         dog.updatedAt = new Date(0);
@@ -138,42 +138,42 @@ describe("Model", () => {
         expect(loadedDog).toBeDefined();
         expect(loadedDog.updatedAt).toEqual(now);
     });
-    test("Force save skip updated field", async () => {
+    test('Force save skip updated field', async () => {
         const now = new Date();
         now.setMilliseconds(0);
         const dog = new Dog();
-        dog.name = "My dog";
+        dog.name = 'My dog';
         dog.updatedAt = now;
         await expect(dog.save()).resolves.toEqual(true);
         dog.updatedAt = new Date(0);
-        dog.forceSaveProperty("updatedAt");
+        dog.forceSaveProperty('updatedAt');
         await expect(dog.save()).resolves.toEqual(true);
         const loadedDog = await Dog.getByID(dog.id);
         expect(loadedDog).toBeDefined();
         expect(loadedDog.updatedAt).toEqual(new Date(0));
     });
-    test("Force save field", async () => {
+    test('Force save field', async () => {
         const now = new Date();
         now.setMilliseconds(0);
         const dog = new Dog();
-        dog.name = "My dog";
+        dog.name = 'My dog';
         dog.updatedAt = now;
         await expect(dog.save()).resolves.toEqual(true);
-        dog.forceSaveProperty("name");
+        dog.forceSaveProperty('name');
         await expect(dog.save()).resolves.toEqual(true);
         const loadedDog = await Dog.getByID(dog.id);
         expect(loadedDog).toBeDefined();
     });
-    test("Creating a model requires to set all properties", async () => {
+    test('Creating a model requires to set all properties', async () => {
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.createdOn = new Date();
         await expect(m.save()).rejects.toThrow(/count/i);
     });
-    test("Saving a new instance", async () => {
+    test('Saving a new instance', async () => {
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.birthDay = new Date(1990, 0, 1);
@@ -181,40 +181,40 @@ describe("Model", () => {
         expect(m.existsInDatabase).toEqual(true);
         expect(m.createdOn).toBeDate();
         expect(m.id).toBeGreaterThanOrEqual(1);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels where id = ?", [m.id]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels where id = ?', [m.id]);
         expect(rows).toHaveLength(1);
         const row = rows[0];
-        expect(row).toHaveProperty("testModels");
-        const selected = TestModel.fromRow(row["testModels"]);
+        expect(row).toHaveProperty('testModels');
+        const selected = TestModel.fromRow(row['testModels']);
         expect(selected).toEqual(m);
         expect(selected.id).toEqual(m.id);
     });
-    test("You cannot set a relation directly", async () => {
+    test('You cannot set a relation directly', async () => {
         const other = new TestModel();
-        other.name = "My parent";
+        other.name = 'My parent';
         other.isActive = true;
         other.count = 1;
         await other.save();
         expect(other.createdOn).toBeDate();
         expect(other.existsInDatabase).toEqual(true);
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.birthDay = new Date(1990, 0, 1);
         // setRelation is the correct way to do it (it would throw now):
-        //m.setRelation(TestModel.parent, other);
+        // m.setRelation(TestModel.parent, other);
         // but we test what happens if we set the relation the wrong way
         m.parent = other;
         await expect(m.save()).rejects.toThrow(/foreign key/i);
     });
-    test("Save before setting a many to one relation", () => {
+    test('Save before setting a many to one relation', () => {
         const other = new TestModel();
-        other.name = "My parent";
+        other.name = 'My parent';
         other.isActive = true;
         other.count = 1;
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.birthDay = new Date(1990, 0, 1);
@@ -222,20 +222,20 @@ describe("Model", () => {
             m.setRelation(TestModel.parent, other);
         }).toThrow(/not yet saved/i);
     });
-    test("Setting a many to one relation", async () => {
+    test('Setting a many to one relation', async () => {
         const other = new TestModel();
-        other.name = "My parent";
+        other.name = 'My parent';
         other.isActive = true;
         other.count = 1;
         await other.save();
         expect(other.existsInDatabase).toEqual(true);
         if (!other.id) {
-            throw new Error("Save failed");
+            throw new Error('Save failed');
         }
         const counts = [4, 5, 1];
         for (const count of counts) {
             const m = new TestModel();
-            m.name = "My name " + count;
+            m.name = 'My name ' + count;
             m.isActive = true;
             m.count = count;
             m.birthDay = new Date(1990, 0, 1);
@@ -251,7 +251,7 @@ describe("Model", () => {
         const o = await TestModel.getByID(other.id);
         expect(o).toEqual(other);
         if (!o) {
-            throw new Error("Save failed");
+            throw new Error('Save failed');
         }
         const children = await TestModel.children.load(o);
         expect(children).toHaveLength(3);
@@ -259,11 +259,11 @@ describe("Model", () => {
         const sortedChildren = await TestModel.sortedChildren.load(o);
         expect(sortedChildren).toHaveLength(3);
         expect(TestModel.sortedChildren.isLoaded(o)).toBeTrue();
-        expect(sortedChildren.map((c) => c.count)).toEqual([1, 4, 5]);
+        expect(sortedChildren.map(c => c.count)).toEqual([1, 4, 5]);
     });
-    test("Setting a many to one relation by ID", async () => {
+    test('Setting a many to one relation by ID', async () => {
         const other = new TestModel();
-        other.name = "My parent";
+        other.name = 'My parent';
         other.isActive = true;
         other.count = 1;
         await other.save();
@@ -272,7 +272,7 @@ describe("Model", () => {
         expect(other.birthDay).toEqual(null);
         expect(other.createdOn).toBeDate();
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.birthDay = new Date(1990, 0, 1);
@@ -282,24 +282,24 @@ describe("Model", () => {
         expect(m.parentId).toEqual(other.id);
         expect(TestModel.parent.isLoaded(m)).toEqual(false);
         expect(TestModel.parent.isSet(m)).toEqual(false);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels where id = ?", [m.id]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels where id = ?', [m.id]);
         expect(rows).toHaveLength(1);
         const row = rows[0];
-        expect(row).toHaveProperty("testModels");
-        const selected = TestModel.fromRow(row["testModels"]);
+        expect(row).toHaveProperty('testModels');
+        const selected = TestModel.fromRow(row['testModels']);
         expect(TestModel.parent.isLoaded(selected)).toEqual(false);
         expect(TestModel.parent.isSet(selected)).toEqual(false);
         expect(selected.parentId).toEqual(other.id);
     });
-    test("Clearing a many to one relation", async () => {
+    test('Clearing a many to one relation', async () => {
         const other = new TestModel();
-        other.name = "My parent";
+        other.name = 'My parent';
         other.isActive = true;
         other.count = 1;
         await other.save();
         expect(other.existsInDatabase).toEqual(true);
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.parentId = other.id;
@@ -312,22 +312,22 @@ describe("Model", () => {
         await m.save();
         expect(m.parentId).toEqual(null);
         expect(m.parent).toEqual(null);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels where id = ?", [m.id]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels where id = ?', [m.id]);
         expect(rows).toHaveLength(1);
         const row = rows[0];
-        expect(row).toHaveProperty("testModels");
-        const selected = TestModel.fromRow(row["testModels"]);
+        expect(row).toHaveProperty('testModels');
+        const selected = TestModel.fromRow(row['testModels']);
         expect(selected.parentId).toEqual(null);
     });
-    test("Clearing a many to one relation by ID", async () => {
+    test('Clearing a many to one relation by ID', async () => {
         const other = new TestModel();
-        other.name = "My parent";
+        other.name = 'My parent';
         other.isActive = true;
         other.count = 1;
         expect(await other.save()).toEqual(true);
         expect(other.existsInDatabase).toEqual(true);
         const m = new TestModel();
-        m.name = "My name";
+        m.name = 'My name';
         m.isActive = true;
         m.count = 1;
         m.parentId = other.id;
@@ -337,16 +337,16 @@ describe("Model", () => {
         m.parentId = null;
         expect(await m.save()).toEqual(true);
         expect(m.parentId).toEqual(null);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels where id = ?", [m.id]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels where id = ?', [m.id]);
         expect(rows).toHaveLength(1);
         const row = rows[0];
-        expect(row).toHaveProperty("testModels");
-        const selected = TestModel.fromRow(row["testModels"]);
+        expect(row).toHaveProperty('testModels');
+        const selected = TestModel.fromRow(row['testModels']);
         expect(selected.parentId).toEqual(null);
     });
-    test("No query if no changes", async () => {
+    test('No query if no changes', async () => {
         const other = new TestModel();
-        other.name = "No query if no changes";
+        other.name = 'No query if no changes';
         other.isActive = true;
         other.count = 1;
         const firstSave = await other.save();
@@ -358,9 +358,9 @@ describe("Model", () => {
         const saved = await other.save();
         expect(saved).toEqual(false);
     });
-    test("Update a model", async () => {
+    test('Update a model', async () => {
         const other = new TestModel();
-        other.name = "Update a model";
+        other.name = 'Update a model';
         other.isActive = true;
         other.count = 1;
         expect(other.existsInDatabase).toEqual(false);
@@ -372,24 +372,24 @@ describe("Model", () => {
     });
     let friend1, friend2, friend3, meWithoutFriends;
     let meWithFriends;
-    test("Set a many to many relationship", async () => {
+    test('Set a many to many relationship', async () => {
         friend1 = new TestModel();
-        friend1.name = "Friend 1";
+        friend1.name = 'Friend 1';
         friend1.isActive = true;
         friend1.count = 1;
         expect(await friend1.save()).toEqual(true);
         friend2 = new TestModel();
-        friend2.name = "Friend 2";
+        friend2.name = 'Friend 2';
         friend2.isActive = true;
         friend2.count = 2;
         expect(await friend2.save()).toEqual(true);
         friend3 = new TestModel();
-        friend3.name = "Friend 3";
+        friend3.name = 'Friend 3';
         friend3.isActive = true;
         friend3.count = 3;
         expect(await friend3.save()).toEqual(true);
         meWithFriends = new TestModel().setManyRelation(TestModel.friends, []);
-        meWithFriends.name = "Me";
+        meWithFriends.name = 'Me';
         meWithFriends.isActive = true;
         meWithFriends.count = 1;
         expect(await meWithFriends.save()).toEqual(true);
@@ -400,41 +400,41 @@ describe("Model", () => {
             expect(meWithFriends.friends[1].id).toEqual(friend2.id);
         }
         else {
-            expect("other friends not loaded").toEqual("other friends loaded");
+            expect('other friends not loaded').toEqual('other friends loaded');
         }
         // Check also saved in database
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " + TestModel.friends.joinQuery("testModels", "friends") + " where testModels.id = ?", [
+        const [rows] = await Database_1.Database.select('SELECT * from testModels ' + TestModel.friends.joinQuery('testModels', 'friends') + ' where testModels.id = ?', [
             meWithFriends.id,
         ]);
-        const _meWithoutFriends = TestModel.fromRow(rows[0]["testModels"]);
+        const _meWithoutFriends = TestModel.fromRow(rows[0]['testModels']);
         expect(_meWithoutFriends).toBeDefined();
         if (!_meWithoutFriends)
             return;
         meWithoutFriends = _meWithoutFriends;
         expect(meWithoutFriends.id).toEqual(meWithFriends.id);
-        const friends = TestModel.fromRows(rows, "friends");
+        const friends = TestModel.fromRows(rows, 'friends');
         expect(friends).toHaveLength(2);
         expect(friends[0].id).toEqual(friend1.id);
         expect(friends[1].id).toEqual(friend2.id);
     });
-    test("Set a sorted many to many relationship", async () => {
+    test('Set a sorted many to many relationship', async () => {
         const friend1 = new TestModel();
-        friend1.name = "Friend 1";
+        friend1.name = 'Friend 1';
         friend1.isActive = true;
         friend1.count = 1;
         expect(await friend1.save()).toEqual(true);
         const friend2 = new TestModel();
-        friend2.name = "Friend 2";
+        friend2.name = 'Friend 2';
         friend2.isActive = true;
         friend2.count = 2;
         expect(await friend2.save()).toEqual(true);
         const friend3 = new TestModel();
-        friend3.name = "Friend 3";
+        friend3.name = 'Friend 3';
         friend3.isActive = true;
         friend3.count = 3;
         expect(await friend3.save()).toEqual(true);
         const meWithFriends = new TestModel().setManyRelation(TestModel.sortedFriends, []);
-        meWithFriends.name = "Me";
+        meWithFriends.name = 'Me';
         meWithFriends.isActive = true;
         meWithFriends.count = 1;
         expect(await meWithFriends.save()).toEqual(true);
@@ -446,19 +446,19 @@ describe("Model", () => {
             expect(meWithFriends.sortedFriends[2].id).toEqual(friend3.id);
         }
         else {
-            expect("other friends not loaded").toEqual("other friends loaded");
+            expect('other friends not loaded').toEqual('other friends loaded');
         }
         // Check also saved in database
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " +
-            TestModel.sortedFriends.joinQuery("testModels", "sortedFriends") +
-            " where testModels.id = ? " +
-            TestModel.sortedFriends.orderByQuery("testModels", "sortedFriends"), [meWithFriends.id]);
-        const meWithoutFriends = TestModel.fromRow(rows[0]["testModels"]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels '
+            + TestModel.sortedFriends.joinQuery('testModels', 'sortedFriends')
+            + ' where testModels.id = ? '
+            + TestModel.sortedFriends.orderByQuery('testModels', 'sortedFriends'), [meWithFriends.id]);
+        const meWithoutFriends = TestModel.fromRow(rows[0]['testModels']);
         expect(meWithoutFriends).toBeDefined();
         if (!meWithoutFriends)
             return;
         expect(meWithoutFriends.id).toEqual(meWithFriends.id);
-        const friends = TestModel.fromRows(rows, "sortedFriends");
+        const friends = TestModel.fromRows(rows, 'sortedFriends');
         expect(friends).toHaveLength(3);
         expect(friends[0].id).toEqual(friend3.id);
         expect(friends[1].id).toEqual(friend2.id);
@@ -473,7 +473,7 @@ describe("Model", () => {
         expect(__friends[1].id).toEqual(friend3.id);
         expect(__friends[2].id).toEqual(friend1.id);
     });
-    test("Unlink a many to many relationship", async () => {
+    test('Unlink a many to many relationship', async () => {
         // Now unlink one
         await TestModel.friends.unlink(meWithFriends, friend1);
         if (TestModel.friends.isLoaded(meWithFriends)) {
@@ -481,121 +481,121 @@ describe("Model", () => {
             expect(meWithFriends.friends[0].id).toEqual(friend2.id);
         }
         else {
-            expect("other friends not loaded").toEqual("other friends loaded");
+            expect('other friends not loaded').toEqual('other friends loaded');
         }
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " + TestModel.friends.joinQuery("testModels", "friends") + " where testModels.id = ?", [
+        const [rows] = await Database_1.Database.select('SELECT * from testModels ' + TestModel.friends.joinQuery('testModels', 'friends') + ' where testModels.id = ?', [
             meWithFriends.id,
         ]);
-        const meAgain = TestModel.fromRow(rows[0]["testModels"]);
+        const meAgain = TestModel.fromRow(rows[0]['testModels']);
         expect(meAgain).toBeDefined();
         if (!meAgain)
             return;
         expect(meAgain.id).toEqual(meWithFriends.id);
-        const friendsAgain = TestModel.fromRows(rows, "friends");
+        const friendsAgain = TestModel.fromRows(rows, 'friends');
         expect(friendsAgain).toHaveLength(1);
         expect(friendsAgain[0].id).toEqual(friend2.id);
     });
-    test("Clear a many to many relationship", async () => {
+    test('Clear a many to many relationship', async () => {
         // Now unlink one
         await TestModel.friends.clear(meWithFriends);
         if (TestModel.friends.isLoaded(meWithFriends)) {
             expect(meWithFriends.friends).toHaveLength(0);
         }
         else {
-            expect("other friends not loaded").toEqual("other friends loaded");
+            expect('other friends not loaded').toEqual('other friends loaded');
         }
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " + TestModel.friends.joinQuery("testModels", "friends") + " where testModels.id = ?", [
+        const [rows] = await Database_1.Database.select('SELECT * from testModels ' + TestModel.friends.joinQuery('testModels', 'friends') + ' where testModels.id = ?', [
             meWithFriends.id,
         ]);
-        const meAgain = TestModel.fromRow(rows[0]["testModels"]);
+        const meAgain = TestModel.fromRow(rows[0]['testModels']);
         expect(meAgain).toBeDefined();
         if (!meAgain)
             return;
         expect(meAgain.id).toEqual(meWithFriends.id);
-        const friendsAgain = TestModel.fromRows(rows, "friends");
+        const friendsAgain = TestModel.fromRows(rows, 'friends');
         expect(friendsAgain).toHaveLength(0);
     });
-    test("Link a not loaded many to many relation", async () => {
+    test('Link a not loaded many to many relation', async () => {
         // Now unlink one
         await TestModel.friends.link(meWithoutFriends, [friend3, friend2, friend1], { priority: [30, 20, 10] });
         expect(TestModel.friends.isLoaded(meWithoutFriends)).toEqual(false);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " + TestModel.friends.joinQuery("testModels", "friends") + " where testModels.id = ?", [
+        const [rows] = await Database_1.Database.select('SELECT * from testModels ' + TestModel.friends.joinQuery('testModels', 'friends') + ' where testModels.id = ?', [
             meWithoutFriends.id,
         ]);
-        const meAgain = TestModel.fromRow(rows[0]["testModels"]);
+        const meAgain = TestModel.fromRow(rows[0]['testModels']);
         expect(meAgain).toBeDefined();
         if (!meAgain)
             return;
         expect(meAgain.id).toEqual(meWithoutFriends.id);
-        const friendsAgain = TestModel.fromRows(rows, "friends");
+        const friendsAgain = TestModel.fromRows(rows, 'friends');
         expect(friendsAgain).toHaveLength(3);
-        expect(friendsAgain.map((f) => f.id)).toIncludeSameMembers([friend3.id, friend2.id, friend1.id]);
+        expect(friendsAgain.map(f => f.id)).toIncludeSameMembers([friend3.id, friend2.id, friend1.id]);
     });
-    test("Unlink a not loaded many to many relation", async () => {
+    test('Unlink a not loaded many to many relation', async () => {
         // Now unlink one
         await TestModel.friends.unlink(meWithoutFriends, friend3);
         expect(TestModel.friends.isLoaded(meWithoutFriends)).toEqual(false);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " + TestModel.friends.joinQuery("testModels", "friends") + " where testModels.id = ?", [
+        const [rows] = await Database_1.Database.select('SELECT * from testModels ' + TestModel.friends.joinQuery('testModels', 'friends') + ' where testModels.id = ?', [
             meWithoutFriends.id,
         ]);
-        const meAgain = TestModel.fromRow(rows[0]["testModels"]);
+        const meAgain = TestModel.fromRow(rows[0]['testModels']);
         expect(meAgain).toBeDefined();
         if (!meAgain)
             return;
         expect(meAgain.id).toEqual(meWithoutFriends.id);
-        const friendsAgain = TestModel.fromRows(rows, "friends");
-        expect(friendsAgain.map((f) => f.id)).toIncludeSameMembers([friend2.id, friend1.id]);
+        const friendsAgain = TestModel.fromRows(rows, 'friends');
+        expect(friendsAgain.map(f => f.id)).toIncludeSameMembers([friend2.id, friend1.id]);
     });
-    test("Load a M2M relation", async () => {
+    test('Load a M2M relation', async () => {
         // Get a clean one, because we don't want to affect the other tests
-        const [rows] = await Database_1.Database.select("SELECT * from testModels where id = ? LIMIT 1", [meWithFriends.id]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels where id = ? LIMIT 1', [meWithFriends.id]);
         expect(rows).toHaveLength(1);
         const row = rows[0];
-        expect(row).toHaveProperty("testModels");
-        const selected = TestModel.fromRow(row["testModels"]);
+        expect(row).toHaveProperty('testModels');
+        const selected = TestModel.fromRow(row['testModels']);
         expect(selected).toBeDefined();
         expect(TestModel.friends.isLoaded(selected)).toEqual(false);
         const friends = await TestModel.friends.load(selected);
         expect(TestModel.friends.isLoaded(selected)).toEqual(true);
         expect(selected.friends).toEqual(friends);
-        expect(friends.map((f) => f.id)).toIncludeSameMembers([friend2.id, friend1.id]);
+        expect(friends.map(f => f.id)).toIncludeSameMembers([friend2.id, friend1.id]);
         expect(friends[0]._link).toMatchObject({
-            priority: friends[0].id == friend2.id ? 20 : 10,
+            priority: friends[0].id === friend2.id ? 20 : 10,
             testModelsIdA: meWithFriends.id,
-            testModelsIdB: friends[0].id
+            testModelsIdB: friends[0].id,
         });
         expect(friends[1]._link).toMatchObject({
-            priority: friends[1].id == friend2.id ? 20 : 10,
+            priority: friends[1].id === friend2.id ? 20 : 10,
             testModelsIdA: meWithFriends.id,
-            testModelsIdB: friends[1].id
+            testModelsIdB: friends[1].id,
         });
         const sortedFriends = await TestModel.sortedFriends.load(selected);
         expect(TestModel.sortedFriends.isLoaded(selected)).toEqual(true);
-        expect(sortedFriends.map((f) => f.id)).toEqual([friend1.id, friend2.id]);
+        expect(sortedFriends.map(f => f.id)).toEqual([friend1.id, friend2.id]);
     });
-    test("Clear a not loaded many to many relation", async () => {
+    test('Clear a not loaded many to many relation', async () => {
         // Now unlink one
         await TestModel.friends.clear(meWithoutFriends);
         expect(TestModel.friends.isLoaded(meWithoutFriends)).toEqual(true); // should be true, because we can automatically load the relation if it is not yet loaded
         expect(meWithoutFriends.friends).toHaveLength(0);
-        const [rows] = await Database_1.Database.select("SELECT * from testModels " + TestModel.friends.joinQuery("testModels", "friends") + " where testModels.id = ?", [
+        const [rows] = await Database_1.Database.select('SELECT * from testModels ' + TestModel.friends.joinQuery('testModels', 'friends') + ' where testModels.id = ?', [
             meWithoutFriends.id,
         ]);
-        const meAgain = TestModel.fromRow(rows[0]["testModels"]);
+        const meAgain = TestModel.fromRow(rows[0]['testModels']);
         expect(meAgain).toBeDefined();
         if (!meAgain)
             return;
         expect(meAgain.id).toEqual(meWithoutFriends.id);
-        const friendsAgain = TestModel.fromRows(rows, "friends");
+        const friendsAgain = TestModel.fromRows(rows, 'friends');
         expect(friendsAgain).toHaveLength(0);
     });
-    test("Load an empty M2M relation", async () => {
+    test('Load an empty M2M relation', async () => {
         // Get a clean one, because we don't want to affect the other tests
-        const [rows] = await Database_1.Database.select("SELECT * from testModels where id = ? LIMIT 1", [meWithFriends.id]);
+        const [rows] = await Database_1.Database.select('SELECT * from testModels where id = ? LIMIT 1', [meWithFriends.id]);
         expect(rows).toHaveLength(1);
         const row = rows[0];
-        expect(row).toHaveProperty("testModels");
-        const selected = TestModel.fromRow(row["testModels"]);
+        expect(row).toHaveProperty('testModels');
+        const selected = TestModel.fromRow(row['testModels']);
         expect(selected).toBeDefined();
         expect(TestModel.friends.isLoaded(selected)).toEqual(false);
         const friends = await TestModel.friends.load(selected);
@@ -605,25 +605,25 @@ describe("Model", () => {
     });
     test("You can't set many to many if not yet saved", async () => {
         const friend1 = new TestModel();
-        friend1.name = "Friend 1";
+        friend1.name = 'Friend 1';
         friend1.isActive = true;
         friend1.count = 1;
         expect(await friend1.save()).toEqual(true);
         const friend2 = new TestModel();
-        friend2.name = "Friend 2";
+        friend2.name = 'Friend 2';
         friend2.isActive = true;
         friend2.count = 1;
         const other = new TestModel().setManyRelation(TestModel.friends, []);
-        other.name = "Me";
+        other.name = 'Me';
         other.isActive = true;
         other.count = 1;
         expect(await other.save()).toEqual(true);
         await expect(TestModel.friends.link(other, [friend1, friend2])).rejects.toThrow(/not saved yet/);
     });
-    test("Get by IDs", async () => {
+    test('Get by IDs', async () => {
         const models = await TestModel.getByIDs(friend1.id, friend2.id, friend3.id, meWithFriends.id);
         expect(models).toHaveLength(4);
-        expect(models.map((e) => e.id)).toIncludeAllMembers([friend1.id, friend2.id, friend3.id, meWithFriends.id]);
+        expect(models.map(e => e.id)).toIncludeAllMembers([friend1.id, friend2.id, friend3.id, meWithFriends.id]);
     });
 });
 //# sourceMappingURL=Model.test.js.map