remult 0.14.6 → 0.14.7

package/src/shared-tests/db-tests.db-tests.js

@@ -1,723 +1,1629 @@
-import { __decorate, __metadata } from "tslib";
-import { DataApi } from "../data-api";
-import { Fields, Entity, EntityBase, Field } from "../remult3";
-import { c } from "../tests/c";
-import { Done } from "../tests/Done";
-import { h } from "../tests/h";
-import { Categories as newCategories } from "../tests/remult-3-entities";
-import { tasks } from "../tests/tasks";
-import { TestDataApiResponse } from "../tests/TestDataApiResponse";
-import { testAll, testAllDbs } from "./db-tests-setup";
-import { entityWithValidations, testConfiguration } from "./entityWithValidations";
-import { Remult } from "../context";
-import { dWithPrefilter } from "../tests/dWithPrefilter";
-import { entityFilterToJson, Filter } from "../filter/filter-interfaces";
-import { d } from "../tests/d";
-import { entityForCustomFilter1 } from "../tests/entityForCustomFilter";
-import { entityWithValidationsOnColumn } from "../tests/entityWithValidationsOnColumn";
-import { Validators } from "../validators";
-import { Status } from "../tests/testModel/models";
-import { IdEntity } from "../id-entity";
-testAll("what", async ({ remult, createEntity }) => {
-    await (await createEntity(stam)).create({ id: 1, title: 'noam' }).save();
-    expect(await remult.repo(stam).count()).toBe(1);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityWithString = exports.tasksWithStringEnum = exports.Priority = exports.tasksWithEnum = exports.stam = void 0;
+var tslib_1 = require("tslib");
+var data_api_1 = require("../data-api");
+var remult3_1 = require("../remult3");
+var c_1 = require("../tests/c");
+var Done_1 = require("../tests/Done");
+var h_1 = require("../tests/h");
+var remult_3_entities_1 = require("../tests/remult-3-entities");
+var tasks_1 = require("../tests/tasks");
+var TestDataApiResponse_1 = require("../tests/TestDataApiResponse");
+var db_tests_setup_1 = require("./db-tests-setup");
+var entityWithValidations_1 = require("./entityWithValidations");
+var context_1 = require("../context");
+var dWithPrefilter_1 = require("../tests/dWithPrefilter");
+var filter_interfaces_1 = require("../filter/filter-interfaces");
+var d_1 = require("../tests/d");
+var entityForCustomFilter_1 = require("../tests/entityForCustomFilter");
+var entityWithValidationsOnColumn_1 = require("../tests/entityWithValidationsOnColumn");
+var validators_1 = require("../validators");
+var models_1 = require("../tests/testModel/models");
+var id_entity_1 = require("../id-entity");
+db_tests_setup_1.testAll("what", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(stam)];
+                case 1: return [4 /*yield*/, (_c.sent()).create({ id: 1, title: 'noam' }).save()];
+                case 2:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, remult.repo(stam).count()];
+                case 3:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("filter works on all db", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ where: { myId: [1, 3] } })).length).toBe(2);
+db_tests_setup_1.testAll("filter works on all db", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { myId: [1, 3] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test in statement and ", async ({ createEntity }) => {
-    const repo = await entityWithValidations.create4RowsInDp(createEntity);
-    expect(await repo.count({ myId: [1, 3], $and: [{ myId: [3] }] })).toBe(1);
+db_tests_setup_1.testAll("test in statement and ", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    repo = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, repo.count({ myId: [1, 3], $and: [{ myId: [3] }] })];
+                case 2:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("filter with and", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ where: { $and: [{ myId: 1 }, { myId: 3 }] } })).length).toBe(0);
+db_tests_setup_1.testAll("filter with and", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { $and: [{ myId: 1 }, { myId: 3 }] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test empty in", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ where: { myId: [] } })).length).toBe(0);
+db_tests_setup_1.testAll("test empty in", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { myId: [] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("filter works on all db or", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ where: { $or: [{ myId: 1 }, { myId: 3 }] } })).length).toBe(2);
+db_tests_setup_1.testAll("filter works on all db or", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { $or: [{ myId: 1 }, { myId: 3 }] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("filter works on all db or_1", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ where: { $or: [{}, {}] } })).length).toBe(4);
+db_tests_setup_1.testAll("filter works on all db or_1", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { $or: [{}, {}] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(4);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("filter works on all db or_2", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ where: { $or: [{}, { myId: 3 }] } })).length).toBe(4);
+db_tests_setup_1.testAll("filter works on all db or_2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { $or: [{}, { myId: 3 }] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(4);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("entity with different id column still works well", async ({ createEntity }) => {
-    let s = await createEntity(entityWithValidations);
-    let c = s.create();
-    c.myId = 1;
-    c.name = 'noam';
-    await c._.save();
-    c.name = 'yael';
-    await c._.save();
-    expect(c.name).toBe('yael');
-    expect((await s.find()).length).toBe(1);
+db_tests_setup_1.testAll("entity with different id column still works well", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, c, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(entityWithValidations_1.entityWithValidations)];
+                case 1:
+                    s = _c.sent();
+                    c = s.create();
+                    c.myId = 1;
+                    c.name = 'noam';
+                    return [4 /*yield*/, c._.save()];
+                case 2:
+                    _c.sent();
+                    c.name = 'yael';
+                    return [4 /*yield*/, c._.save()];
+                case 3:
+                    _c.sent();
+                    expect(c.name).toBe('yael');
+                    _b = expect;
+                    return [4 /*yield*/, s.find()];
+                case 4:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("empty find works", async ({ remult, createEntity }) => {
-    let c = (await createEntity(newCategories)).create();
-    c.id = 5;
-    c.categoryName = 'test';
-    await c._.save();
-    let l = await remult.repo(newCategories).find();
-    expect(l.length).toBe(1);
-    expect(l[0].categoryName).toBe('test');
+db_tests_setup_1.testAll("empty find works", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, l;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    c = (_b.sent()).create();
+                    c.id = 5;
+                    c.categoryName = 'test';
+                    return [4 /*yield*/, c._.save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).find()];
+                case 3:
+                    l = _b.sent();
+                    expect(l.length).toBe(1);
+                    expect(l[0].categoryName).toBe('test');
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test descending", async ({ createEntity }) => {
-    const repo = await createEntity(newCategories);
-    await repo.create({ id: 1, categoryName: 'a' }).save();
-    await repo.create({ id: 2, categoryName: 'b' }).save();
-    const rows = await repo.find({
-        orderBy: { categoryName: 'desc' },
-        page: -1
-    });
-    expect(rows[0].id).toBe(2);
+db_tests_setup_1.testAll("test descending", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    repo = _b.sent();
+                    return [4 /*yield*/, repo.create({ id: 1, categoryName: 'a' }).save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, repo.create({ id: 2, categoryName: 'b' }).save()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, repo.find({
+                            orderBy: { categoryName: 'desc' },
+                            page: -1
+                        })];
+                case 4:
+                    rows = _b.sent();
+                    expect(rows[0].id).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test descending 2", async ({ createEntity }) => {
-    const repo = await createEntity(newCategories);
-    await repo.insert([{ id: 1, categoryName: 'a' }, { id: 2, categoryName: 'b' }]);
-    const rows = await repo.find({
-        orderBy: { categoryName: 'desc' },
-        page: -1
-    });
-    expect(rows[0].id).toBe(2);
+db_tests_setup_1.testAll("test descending 2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    repo = _b.sent();
+                    return [4 /*yield*/, repo.insert([{ id: 1, categoryName: 'a' }, { id: 2, categoryName: 'b' }])];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, repo.find({
+                            orderBy: { categoryName: 'desc' },
+                            page: -1
+                        })];
+                case 3:
+                    rows = _b.sent();
+                    expect(rows[0].id).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("partial updates", async ({ remult, createEntity }) => {
-    let c = (await createEntity(newCategories)).create({
-        id: 5, categoryName: 'test', description: 'desc'
-    });
-    await c._.save();
-    let l = await remult.repo(newCategories).findId(5);
-    c.categoryName = 'newname';
-    l.description = 'new desc';
-    await c.save();
-    await l.save();
-    expect(l.categoryName).toBe('newname');
-    expect(l.description).toBe('new desc');
+db_tests_setup_1.testAll("partial updates", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, l;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(remult_3_entities_1.Categories)];
+                case 1:
+                    c = (_b.sent()).create({
+                        id: 5, categoryName: 'test', description: 'desc'
+                    });
+                    return [4 /*yield*/, c._.save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, remult.repo(remult_3_entities_1.Categories).findId(5)];
+                case 3:
+                    l = _b.sent();
+                    c.categoryName = 'newname';
+                    l.description = 'new desc';
+                    return [4 /*yield*/, c.save()];
+                case 4:
+                    _b.sent();
+                    return [4 /*yield*/, l.save()];
+                case 5:
+                    _b.sent();
+                    expect(l.categoryName).toBe('newname');
+                    expect(l.description).toBe('new desc');
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("put with validations on entity fails", async ({ remult, createEntity }) => {
-    let s = await createEntity(entityWithValidations);
-    let c = s.create();
-    c.myId = 1;
-    c.name = 'noam';
-    await c._.save();
-    let api = new DataApi(s, remult);
-    let t = new TestDataApiResponse();
-    let d = new Done();
-    t.error = async (data) => {
-        expect(data.modelState.name).toBe('invalid');
-        d.ok();
-    };
-    await api.put(t, 1, {
-        name: '1'
-    });
-    d.test();
-    var x = await s.find({ where: { myId: 1 } });
-    expect(x[0].name).toBe('noam');
-    x = await s.find({ where: { myId: 1 } });
-    expect(x[0].name).toBe('noam');
+db_tests_setup_1.testAll("put with validations on entity fails", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, c, api, t, d, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(entityWithValidations_1.entityWithValidations)];
+                case 1:
+                    s = _b.sent();
+                    c = s.create();
+                    c.myId = 1;
+                    c.name = 'noam';
+                    return [4 /*yield*/, c._.save()];
+                case 2:
+                    _b.sent();
+                    api = new data_api_1.DataApi(s, remult);
+                    t = new TestDataApiResponse_1.TestDataApiResponse();
+                    d = new Done_1.Done();
+                    t.error = function (data) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            expect(data.modelState.name).toBe('invalid');
+                            d.ok();
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    return [4 /*yield*/, api.put(t, 1, {
+                            name: '1'
+                        })];
+                case 3:
+                    _b.sent();
+                    d.test();
+                    return [4 /*yield*/, s.find({ where: { myId: 1 } })];
+                case 4:
+                    x = _b.sent();
+                    expect(x[0].name).toBe('noam');
+                    return [4 /*yield*/, s.find({ where: { myId: 1 } })];
+                case 5:
+                    x = _b.sent();
+                    expect(x[0].name).toBe('noam');
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test date with null works", async ({ createEntity }) => {
-    let repo = await createEntity(testDateWithNull);
-    let r = repo.create({ id: 0 });
-    await r.save();
-    r = await repo.findFirst();
-    expect(r.d).toBeNull();
-    expect(await repo.count({ d: null })).toBe(1);
+db_tests_setup_1.testAll("test date with null works", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, r, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(testDateWithNull)];
+                case 1:
+                    repo = _c.sent();
+                    r = repo.create({ id: 0 });
+                    return [4 /*yield*/, r.save()];
+                case 2:
+                    _c.sent();
+                    return [4 /*yield*/, repo.findFirst()];
+                case 3:
+                    r = _c.sent();
+                    expect(r.d).toBeNull();
+                    _b = expect;
+                    return [4 /*yield*/, repo.count({ d: null })];
+                case 4:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test original value of date", async ({ createEntity }) => {
-    let r = await (await createEntity(testDateWithNull)).create({ id: 1, d: new Date(1976, 6, 16) }).save();
-    expect(r.$.d.originalValue.getFullYear()).toBe(1976);
+db_tests_setup_1.testAll("test original value of date", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(testDateWithNull)];
+                case 1: return [4 /*yield*/, (_b.sent()).create({ id: 1, d: new Date(1976, 6, 16) }).save()];
+                case 2:
+                    r = _b.sent();
+                    expect(r.$.d.originalValue.getFullYear()).toBe(1976);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-let testDateWithNull = class testDateWithNull extends EntityBase {
-    constructor() {
-        super(...arguments);
-        this.id = 0;
+var testDateWithNull = /** @class */ (function (_super) {
+    tslib_1.__extends(testDateWithNull, _super);
+    function testDateWithNull() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = 0;
+        return _this;
     }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], testDateWithNull.prototype, "id", void 0);
-__decorate([
-    Fields.dateOnly({ allowNull: true }),
-    __metadata("design:type", Date)
-], testDateWithNull.prototype, "d", void 0);
-testDateWithNull = __decorate([
-    Entity('testDateWithNull', { allowApiCrud: true })
-], testDateWithNull);
-testAll("test string with null works", async ({ createEntity }) => {
-    let repo = await createEntity(testStringWithNull);
-    let r = repo.create({ id: 0 });
-    await r.save();
-    r = await repo.findFirst();
-    expect(r.d).toBeNull();
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], testDateWithNull.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.dateOnly({ allowNull: true }),
+        tslib_1.__metadata("design:type", Date)
+    ], testDateWithNull.prototype, "d", void 0);
+    testDateWithNull = tslib_1.__decorate([
+        remult3_1.Entity('testDateWithNull', { allowApiCrud: true })
+    ], testDateWithNull);
+    return testDateWithNull;
+}(remult3_1.EntityBase));
+db_tests_setup_1.testAll("test string with null works", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, r;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(testStringWithNull)];
+                case 1:
+                    repo = _b.sent();
+                    r = repo.create({ id: 0 });
+                    return [4 /*yield*/, r.save()];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, repo.findFirst()];
+                case 3:
+                    r = _b.sent();
+                    expect(r.d).toBeNull();
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test tasks", async ({ createEntity }) => {
-    let c = await createEntity(tasks);
-    let t = c.create();
-    t.id = 1;
-    await t._.save();
-    t = c.create();
-    t.id = 2;
-    t.completed = true;
-    await t._.save();
-    t = c.create();
-    t.id = 3;
-    t.completed = true;
-    await t._.save();
-    await c.create({ id: 4, completed: false }).save();
-    expect(await c.count({ completed: false })).toBe(2);
-    expect(await c.count({ completed: { $ne: true } })).toBe(2);
-    expect(await c.count({ completed: true })).toBe(2);
+db_tests_setup_1.testAll("test tasks", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, t, _b, _c, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createEntity(tasks_1.tasks)];
+                case 1:
+                    c = _e.sent();
+                    t = c.create();
+                    t.id = 1;
+                    return [4 /*yield*/, t._.save()];
+                case 2:
+                    _e.sent();
+                    t = c.create();
+                    t.id = 2;
+                    t.completed = true;
+                    return [4 /*yield*/, t._.save()];
+                case 3:
+                    _e.sent();
+                    t = c.create();
+                    t.id = 3;
+                    t.completed = true;
+                    return [4 /*yield*/, t._.save()];
+                case 4:
+                    _e.sent();
+                    return [4 /*yield*/, c.create({ id: 4, completed: false }).save()];
+                case 5:
+                    _e.sent();
+                    _b = expect;
+                    return [4 /*yield*/, c.count({ completed: false })];
+                case 6:
+                    _b.apply(void 0, [_e.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, c.count({ completed: { $ne: true } })];
+                case 7:
+                    _c.apply(void 0, [_e.sent()]).toBe(2);
+                    _d = expect;
+                    return [4 /*yield*/, c.count({ completed: true })];
+                case 8:
+                    _d.apply(void 0, [_e.sent()]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test filtering of null/''", async ({ createEntity }) => {
-    let repo = await createEntity(h);
-    let a = await repo.create({ id: 'a' }).save();
-    let b = await repo.create({ id: 'b' }).save();
-    let c = await repo.create({ id: 'c', refH: b }).save();
-    expect(await repo.count({ refH: null })).toBe(2);
-    expect(await repo.count({ refH: { "!=": null } })).toBe(1);
+db_tests_setup_1.testAll("test filtering of null/''", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, a, b, c, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createEntity(h_1.h)];
+                case 1:
+                    repo = _d.sent();
+                    return [4 /*yield*/, repo.create({ id: 'a' }).save()];
+                case 2:
+                    a = _d.sent();
+                    return [4 /*yield*/, repo.create({ id: 'b' }).save()];
+                case 3:
+                    b = _d.sent();
+                    return [4 /*yield*/, repo.create({ id: 'c', refH: b }).save()];
+                case 4:
+                    c = _d.sent();
+                    _b = expect;
+                    return [4 /*yield*/, repo.count({ refH: null })];
+                case 5:
+                    _b.apply(void 0, [_d.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, repo.count({ refH: { "!=": null } })];
+                case 6:
+                    _c.apply(void 0, [_d.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("test paging with complex object", async ({ remult, createEntity }) => {
-    await createEntity(c);
-    await createEntity(p);
-    let c1 = await remult.repo(c).create({ id: 1, name: 'c1' }).save();
-    let c2 = await remult.repo(c).create({ id: 2, name: 'c2' }).save();
-    let c3 = await remult.repo(c).create({ id: 3, name: 'c3' }).save();
-    await remult.repo(p).create({ id: 1, name: 'p1', c: c1 }).save();
-    await remult.repo(p).create({ id: 2, name: 'p2', c: c2 }).save();
-    await remult.repo(p).create({ id: 3, name: 'p3', c: c3 }).save();
-    await remult.repo(p).create({ id: 4, name: 'p4', c: c3 }).save();
-    await remult.repo(p).create({ id: 5, name: 'p5', c: c3 }).save();
-    let i = 0;
-    for await (const x of remult.repo(p).query({
-        orderBy: { c: "asc", id: "asc" }
-    })) {
-        i++;
-    }
-    expect(i).toBe(5);
+db_tests_setup_1.testAll("test paging with complex object", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c1, c2, c3, i, _b, _c, x, e_1_1;
+        var e_1, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createEntity(c_1.c)];
+                case 1:
+                    _e.sent();
+                    return [4 /*yield*/, createEntity(p)];
+                case 2:
+                    _e.sent();
+                    return [4 /*yield*/, remult.repo(c_1.c).create({ id: 1, name: 'c1' }).save()];
+                case 3:
+                    c1 = _e.sent();
+                    return [4 /*yield*/, remult.repo(c_1.c).create({ id: 2, name: 'c2' }).save()];
+                case 4:
+                    c2 = _e.sent();
+                    return [4 /*yield*/, remult.repo(c_1.c).create({ id: 3, name: 'c3' }).save()];
+                case 5:
+                    c3 = _e.sent();
+                    return [4 /*yield*/, remult.repo(p).create({ id: 1, name: 'p1', c: c1 }).save()];
+                case 6:
+                    _e.sent();
+                    return [4 /*yield*/, remult.repo(p).create({ id: 2, name: 'p2', c: c2 }).save()];
+                case 7:
+                    _e.sent();
+                    return [4 /*yield*/, remult.repo(p).create({ id: 3, name: 'p3', c: c3 }).save()];
+                case 8:
+                    _e.sent();
+                    return [4 /*yield*/, remult.repo(p).create({ id: 4, name: 'p4', c: c3 }).save()];
+                case 9:
+                    _e.sent();
+                    return [4 /*yield*/, remult.repo(p).create({ id: 5, name: 'p5', c: c3 }).save()];
+                case 10:
+                    _e.sent();
+                    i = 0;
+                    _e.label = 11;
+                case 11:
+                    _e.trys.push([11, 16, 17, 22]);
+                    _b = tslib_1.__asyncValues(remult.repo(p).query({
+                        orderBy: { c: "asc", id: "asc" }
+                    }));
+                    _e.label = 12;
+                case 12: return [4 /*yield*/, _b.next()];
+                case 13:
+                    if (!(_c = _e.sent(), !_c.done)) return [3 /*break*/, 15];
+                    x = _c.value;
+                    i++;
+                    _e.label = 14;
+                case 14: return [3 /*break*/, 12];
+                case 15: return [3 /*break*/, 22];
+                case 16:
+                    e_1_1 = _e.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 22];
+                case 17:
+                    _e.trys.push([17, , 20, 21]);
+                    if (!(_c && !_c.done && (_d = _b.return))) return [3 /*break*/, 19];
+                    return [4 /*yield*/, _d.call(_b)];
+                case 18:
+                    _e.sent();
+                    _e.label = 19;
+                case 19: return [3 /*break*/, 21];
+                case 20:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 21: return [7 /*endfinally*/];
+                case 22:
+                    expect(i).toBe(5);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test paging with complex object_2", async ({ remult, createEntity }) => {
-    let c1 = await (await createEntity(c)).create({ id: 1, name: 'c1' }).save();
-    await (await createEntity(p)).create({ id: 1, name: 'p1', c: c1 }).save();
-    expect((await remult.repo(p).findFirst({ c: c1 })).id).toBe(1);
+db_tests_setup_1.testAll("test paging with complex object_2", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c1, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(c_1.c)];
+                case 1: return [4 /*yield*/, (_c.sent()).create({ id: 1, name: 'c1' }).save()];
+                case 2:
+                    c1 = _c.sent();
+                    return [4 /*yield*/, createEntity(p)];
+                case 3: return [4 /*yield*/, (_c.sent()).create({ id: 1, name: 'p1', c: c1 }).save()];
+                case 4:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, remult.repo(p).findFirst({ c: c1 })];
+                case 5:
+                    _b.apply(void 0, [(_c.sent()).id]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test filter doesn't collapse", async ({ createEntity }) => {
-    let repo = await createEntity(dWithPrefilter);
-    let d1 = await repo.create({ id: 1, b: 1 }).save();
-    await repo.create({ id: 2, b: 2 }).save();
-    let d4 = await repo.create({ id: 4, b: 2 }).save();
-    let f = { id: 1, $and: [{ id: 2 }] };
-    expect(await repo.count(f)).toBe(0);
-    expect((await repo.find({ where: f })).length).toBe(0);
-    let json = Filter.entityFilterToJson(repo.metadata, f);
-    f = Filter.entityFilterFromJson(repo.metadata, json);
-    expect(await repo.count(f)).toBe(0);
-    expect((await repo.find({ where: f })).length).toBe(0);
+db_tests_setup_1.testAll("test filter doesn't collapse", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, d1, d4, f, _b, _c, json, _d, _e;
+        return tslib_1.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, createEntity(dWithPrefilter_1.dWithPrefilter)];
+                case 1:
+                    repo = _f.sent();
+                    return [4 /*yield*/, repo.create({ id: 1, b: 1 }).save()];
+                case 2:
+                    d1 = _f.sent();
+                    return [4 /*yield*/, repo.create({ id: 2, b: 2 }).save()];
+                case 3:
+                    _f.sent();
+                    return [4 /*yield*/, repo.create({ id: 4, b: 2 }).save()];
+                case 4:
+                    d4 = _f.sent();
+                    f = { id: 1, $and: [{ id: 2 }] };
+                    _b = expect;
+                    return [4 /*yield*/, repo.count(f)];
+                case 5:
+                    _b.apply(void 0, [_f.sent()]).toBe(0);
+                    _c = expect;
+                    return [4 /*yield*/, repo.find({ where: f })];
+                case 6:
+                    _c.apply(void 0, [(_f.sent()).length]).toBe(0);
+                    json = filter_interfaces_1.Filter.entityFilterToJson(repo.metadata, f);
+                    f = filter_interfaces_1.Filter.entityFilterFromJson(repo.metadata, json);
+                    _d = expect;
+                    return [4 /*yield*/, repo.count(f)];
+                case 7:
+                    _d.apply(void 0, [_f.sent()]).toBe(0);
+                    _e = expect;
+                    return [4 /*yield*/, repo.find({ where: f })];
+                case 8:
+                    _e.apply(void 0, [(_f.sent()).length]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test filter doesn't collapse", async ({ createEntity }) => {
-    let repo = await createEntity(d);
-    let d1 = await repo.create({ id: 1, b: 1 }).save();
-    await repo.create({ id: 2, b: 2 }).save();
-    let d4 = await repo.create({ id: 4, b: 2 }).save();
-    let f = { id: [1, 2] };
-    expect(await repo.count(f)).toBe(2);
-    expect((await repo.find({ where: f })).length).toBe(2);
-    let json = Filter.entityFilterToJson(repo.metadata, f);
-    f = Filter.entityFilterFromJson(repo.metadata, json);
-    expect(await repo.count(f)).toBe(2);
-    expect((await repo.find({ where: f })).length).toBe(2);
+db_tests_setup_1.testAll("test filter doesn't collapse", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, d1, d4, f, _b, _c, json, _d, _e;
+        return tslib_1.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0: return [4 /*yield*/, createEntity(d_1.d)];
+                case 1:
+                    repo = _f.sent();
+                    return [4 /*yield*/, repo.create({ id: 1, b: 1 }).save()];
+                case 2:
+                    d1 = _f.sent();
+                    return [4 /*yield*/, repo.create({ id: 2, b: 2 }).save()];
+                case 3:
+                    _f.sent();
+                    return [4 /*yield*/, repo.create({ id: 4, b: 2 }).save()];
+                case 4:
+                    d4 = _f.sent();
+                    f = { id: [1, 2] };
+                    _b = expect;
+                    return [4 /*yield*/, repo.count(f)];
+                case 5:
+                    _b.apply(void 0, [_f.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, repo.find({ where: f })];
+                case 6:
+                    _c.apply(void 0, [(_f.sent()).length]).toBe(2);
+                    json = filter_interfaces_1.Filter.entityFilterToJson(repo.metadata, f);
+                    f = filter_interfaces_1.Filter.entityFilterFromJson(repo.metadata, json);
+                    _d = expect;
+                    return [4 /*yield*/, repo.count(f)];
+                case 7:
+                    _d.apply(void 0, [_f.sent()]).toBe(2);
+                    _e = expect;
+                    return [4 /*yield*/, repo.find({ where: f })];
+                case 8:
+                    _e.apply(void 0, [(_f.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test that it works with inheritance", async ({ createEntity }) => {
-    let c = await createEntity(entityForCustomFilter1);
-    for (let id = 0; id < 5; id++) {
-        await c.create({ id }).save();
-    }
-    expect(await (c.count(entityForCustomFilter1.oneAndThree()))).toBe(2);
-    expect((await (c.findFirst(entityForCustomFilter1.testNumericValue(2)))).id).toBe(2);
-    expect((await (c.findFirst(entityForCustomFilter1.testObjectValue({ val: 2 })))).id).toBe(2);
+db_tests_setup_1.testAll("test that it works with inheritance", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, id, _b, _c, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createEntity(entityForCustomFilter_1.entityForCustomFilter1)];
+                case 1:
+                    c = _e.sent();
+                    id = 0;
+                    _e.label = 2;
+                case 2:
+                    if (!(id < 5)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, c.create({ id: id }).save()];
+                case 3:
+                    _e.sent();
+                    _e.label = 4;
+                case 4:
+                    id++;
+                    return [3 /*break*/, 2];
+                case 5:
+                    _b = expect;
+                    return [4 /*yield*/, (c.count(entityForCustomFilter_1.entityForCustomFilter1.oneAndThree()))];
+                case 6:
+                    _b.apply(void 0, [_e.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, (c.findFirst(entityForCustomFilter_1.entityForCustomFilter1.testNumericValue(2)))];
+                case 7:
+                    _c.apply(void 0, [(_e.sent()).id]).toBe(2);
+                    _d = expect;
+                    return [4 /*yield*/, (c.findFirst(entityForCustomFilter_1.entityForCustomFilter1.testObjectValue({ val: 2 })))];
+                case 8:
+                    _d.apply(void 0, [(_e.sent()).id]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("put with validations on column fails", async ({ remult, createEntity }) => {
-    var s = await createEntity(entityWithValidationsOnColumn);
-    let c = s.create();
-    c.myId = 1;
-    c.name = 'noam';
-    await c._.save();
-    let api = new DataApi(s, remult);
-    let t = new TestDataApiResponse();
-    let d = new Done();
-    t.error = async (data) => {
-        expect(data.modelState.name).toBe('invalid on column');
-        d.ok();
-    };
-    await api.put(t, 1, {
-        name: '1'
-    });
-    d.test();
-    var x = await s.find({ where: { myId: 1 } });
-    expect(x[0].name).toBe('noam');
+db_tests_setup_1.testAll("put with validations on column fails", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, c, api, t, d, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(entityWithValidationsOnColumn_1.entityWithValidationsOnColumn)];
+                case 1:
+                    s = _b.sent();
+                    c = s.create();
+                    c.myId = 1;
+                    c.name = 'noam';
+                    return [4 /*yield*/, c._.save()];
+                case 2:
+                    _b.sent();
+                    api = new data_api_1.DataApi(s, remult);
+                    t = new TestDataApiResponse_1.TestDataApiResponse();
+                    d = new Done_1.Done();
+                    t.error = function (data) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            expect(data.modelState.name).toBe('invalid on column');
+                            d.ok();
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    return [4 /*yield*/, api.put(t, 1, {
+                            name: '1'
+                        })];
+                case 3:
+                    _b.sent();
+                    d.test();
+                    return [4 /*yield*/, s.find({ where: { myId: 1 } })];
+                case 4:
+                    x = _b.sent();
+                    expect(x[0].name).toBe('noam');
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAllDbs("Insert", async ({ createData }) => {
-    let forCat = await createData(async (x) => { });
-    let rows = await forCat.find();
-    expect(rows.length).toBe(0);
-    let c = forCat.create();
-    c.id = 1;
-    c.categoryName = 'noam';
-    await c._.save();
-    rows = await forCat.find();
-    expect(rows.length).toBe(1);
-    expect(rows[0].id).toBe(1);
-    expect(rows[0].categoryName).toBe('noam');
+db_tests_setup_1.testAllDbs("Insert", function (_a) {
+    var createData = _a.createData;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var forCat, rows, c;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createData(function (x) { return tslib_1.__awaiter(void 0, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                        return [2 /*return*/];
+                    }); }); })];
+                case 1:
+                    forCat = _b.sent();
+                    return [4 /*yield*/, forCat.find()];
+                case 2:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(0);
+                    c = forCat.create();
+                    c.id = 1;
+                    c.categoryName = 'noam';
+                    return [4 /*yield*/, c._.save()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, forCat.find()];
+                case 4:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(1);
+                    expect(rows[0].id).toBe(1);
+                    expect(rows[0].categoryName).toBe('noam');
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAllDbs("test delete", async ({ createData }) => {
-    let c = await createData(async (insert) => await insert(5, 'noam'));
-    let rows = await c.find();
-    expect(rows.length).toBe(1);
-    expect(rows[0].id).toBe(5);
-    await rows[0]._.delete();
-    rows = await c.find();
-    expect(rows.length).toBe(0);
+db_tests_setup_1.testAllDbs("test delete", function (_a) {
+    var createData = _a.createData;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createData(function (insert) { return tslib_1.__awaiter(void 0, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, insert(5, 'noam')];
+                            case 1: return [2 /*return*/, _a.sent()];
+                        }
+                    }); }); })];
+                case 1:
+                    c = _b.sent();
+                    return [4 /*yield*/, c.find()];
+                case 2:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(1);
+                    expect(rows[0].id).toBe(5);
+                    return [4 /*yield*/, rows[0]._.delete()];
+                case 3:
+                    _b.sent();
+                    return [4 /*yield*/, c.find()];
+                case 4:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAllDbs("test filter packer", async ({ insertFourRows }) => {
-    let r = await insertFourRows();
-    let rows = await r.find();
-    expect(rows.length).toBe(4);
-    rows = await r.find({
-        where: Filter.entityFilterFromJson(r.metadata, entityFilterToJson(r.metadata, { description: 'x' }))
-    });
-    expect(rows.length).toBe(2);
-    rows = await r.find({ where: Filter.entityFilterFromJson(r.metadata, entityFilterToJson(r.metadata, { id: 4 })) });
-    expect(rows.length).toBe(1);
-    expect(rows[0].categoryName).toBe('yael');
-    rows = await r.find({ where: Filter.entityFilterFromJson(r.metadata, entityFilterToJson(r.metadata, { description: 'y', categoryName: 'yoni' })) });
-    expect(rows.length).toBe(1);
-    expect(rows[0].id).toBe(2);
-    rows = await r.find({ where: Filter.entityFilterFromJson(r.metadata, entityFilterToJson(r.metadata, { id: { $ne: [2, 4] } })) });
-    expect(rows.length).toBe(2);
+db_tests_setup_1.testAllDbs("test filter packer", function (_a) {
+    var insertFourRows = _a.insertFourRows;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, insertFourRows()];
+                case 1:
+                    r = _b.sent();
+                    return [4 /*yield*/, r.find()];
+                case 2:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(4);
+                    return [4 /*yield*/, r.find({
+                            where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { description: 'x' }))
+                        })];
+                case 3:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(2);
+                    return [4 /*yield*/, r.find({ where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { id: 4 })) })];
+                case 4:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(1);
+                    expect(rows[0].categoryName).toBe('yael');
+                    return [4 /*yield*/, r.find({ where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { description: 'y', categoryName: 'yoni' })) })];
+                case 5:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(1);
+                    expect(rows[0].id).toBe(2);
+                    return [4 /*yield*/, r.find({ where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { id: { $ne: [2, 4] } })) })];
+                case 6:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("Test unique Validation,", async ({ createEntity }) => {
-    let type = class extends newCategories {
-    };
-    Entity('categories')(type);
-    Fields.string({
-        validate: async (en, col) => {
-            if (en._.isNew() || en.a != en._.fields.a.originalValue) {
-                if (await c.count({ a: en.a }))
-                    en._.fields.a.error = 'already exists';
-            }
-        }
-    })(type.prototype, "a");
-    var c = await createEntity(type);
-    var cat = c.create();
-    cat.a = '12';
-    cat.id = 1;
-    await cat._.save();
-    cat = c.create();
-    cat.a = '12';
-    var saved = false;
-    try {
-        await cat._.save();
-        saved = true;
-    }
-    catch (err) {
-        expect(cat._.fields.a.error).toEqual("already exists");
-    }
-    expect(saved).toBe(false);
+db_tests_setup_1.testAll("Test unique Validation,", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var type, c, cat, saved, err_1;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    type = /** @class */ (function (_super) {
+                        tslib_1.__extends(class_1, _super);
+                        function class_1() {
+                            return _super !== null && _super.apply(this, arguments) || this;
+                        }
+                        return class_1;
+                    }(remult_3_entities_1.Categories));
+                    remult3_1.Entity('categories')(type);
+                    remult3_1.Fields.string({
+                        validate: function (en, col) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!(en._.isNew() || en.a != en._.fields.a.originalValue)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, c.count({ a: en.a })];
+                                    case 1:
+                                        if (_a.sent())
+                                            en._.fields.a.error = 'already exists';
+                                        _a.label = 2;
+                                    case 2: return [2 /*return*/];
+                                }
+                            });
+                        }); }
+                    })(type.prototype, "a");
+                    return [4 /*yield*/, createEntity(type)];
+                case 1:
+                    c = _b.sent();
+                    cat = c.create();
+                    cat.a = '12';
+                    cat.id = 1;
+                    return [4 /*yield*/, cat._.save()];
+                case 2:
+                    _b.sent();
+                    cat = c.create();
+                    cat.a = '12';
+                    saved = false;
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, cat._.save()];
+                case 4:
+                    _b.sent();
+                    saved = true;
+                    return [3 /*break*/, 6];
+                case 5:
+                    err_1 = _b.sent();
+                    expect(cat._.fields.a.error).toEqual("already exists");
+                    return [3 /*break*/, 6];
+                case 6:
+                    expect(saved).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("Test unique Validation 2", async ({ createEntity }) => {
-    let type = class extends newCategories {
-    };
-    Entity('sdfgds')(type);
-    Fields.string({
-        validate: Validators.unique
-    })(type.prototype, "a");
-    var c = await createEntity(type);
-    var cat = c.create();
-    cat.a = '12';
-    await cat._.save();
-    cat = c.create();
-    cat.a = '12';
-    var saved = false;
-    try {
-        await cat._.save();
-        saved = true;
-    }
-    catch (err) {
-        expect(cat._.fields.a.error).toEqual("already exists");
-    }
-    expect(saved).toBe(false);
+db_tests_setup_1.testAll("Test unique Validation 2", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var type, c, cat, saved, err_2;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    type = /** @class */ (function (_super) {
+                        tslib_1.__extends(class_2, _super);
+                        function class_2() {
+                            return _super !== null && _super.apply(this, arguments) || this;
+                        }
+                        return class_2;
+                    }(remult_3_entities_1.Categories));
+                    remult3_1.Entity('sdfgds')(type);
+                    remult3_1.Fields.string({
+                        validate: validators_1.Validators.unique
+                    })(type.prototype, "a");
+                    return [4 /*yield*/, createEntity(type)];
+                case 1:
+                    c = _b.sent();
+                    cat = c.create();
+                    cat.a = '12';
+                    return [4 /*yield*/, cat._.save()];
+                case 2:
+                    _b.sent();
+                    cat = c.create();
+                    cat.a = '12';
+                    saved = false;
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, cat._.save()];
+                case 4:
+                    _b.sent();
+                    saved = true;
+                    return [3 /*break*/, 6];
+                case 5:
+                    err_2 = _b.sent();
+                    expect(cat._.fields.a.error).toEqual("already exists");
+                    return [3 /*break*/, 6];
+                case 6:
+                    expect(saved).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-let testNumbers = class testNumbers extends EntityBase {
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], testNumbers.prototype, "id", void 0);
-__decorate([
-    Fields.number(),
-    __metadata("design:type", Number)
-], testNumbers.prototype, "a", void 0);
-testNumbers = __decorate([
-    Entity('testNumbers', { allowApiCrud: true })
-], testNumbers);
-testAll("test that integer and int work", async ({ createEntity }) => {
-    let e = await (await createEntity(testNumbers)).create({
-        id: 1.5,
-        a: 1.5
-    }).save();
-    expect(e.id).toBe(2);
-    expect(e.a).toBe(1.5);
+var testNumbers = /** @class */ (function (_super) {
+    tslib_1.__extends(testNumbers, _super);
+    function testNumbers() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], testNumbers.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.number(),
+        tslib_1.__metadata("design:type", Number)
+    ], testNumbers.prototype, "a", void 0);
+    testNumbers = tslib_1.__decorate([
+        remult3_1.Entity('testNumbers', { allowApiCrud: true })
+    ], testNumbers);
+    return testNumbers;
+}(remult3_1.EntityBase));
+db_tests_setup_1.testAll("test that integer and int work", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var e;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(testNumbers)];
+                case 1: return [4 /*yield*/, (_b.sent()).create({
+                        id: 1.5,
+                        a: 1.5
+                    }).save()];
+                case 2:
+                    e = _b.sent();
+                    expect(e.id).toBe(2);
+                    expect(e.a).toBe(1.5);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("post with logic works and max in entity", async ({ remult, createEntity }) => {
-    let c = await createEntity(entityWithValidations);
-    var api = new DataApi(c, remult);
-    let t = new TestDataApiResponse();
-    let d = new Done();
-    t.created = async (data) => {
-        expect(data.name).toBe('noam honig');
-        expect(data.myId).toBe(1);
-        d.ok();
-    };
-    entityWithValidations.savingRowCount = 0;
-    await api.post(t, { name: 'noam honig', myId: 1 });
-    expect(entityWithValidations.savingRowCount).toBe(1);
-    d.test();
+db_tests_setup_1.testAll("post with logic works and max in entity", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, api, t, d;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(entityWithValidations_1.entityWithValidations)];
+                case 1:
+                    c = _b.sent();
+                    api = new data_api_1.DataApi(c, remult);
+                    t = new TestDataApiResponse_1.TestDataApiResponse();
+                    d = new Done_1.Done();
+                    t.created = function (data) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            expect(data.name).toBe('noam honig');
+                            expect(data.myId).toBe(1);
+                            d.ok();
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    entityWithValidations_1.entityWithValidations.savingRowCount = 0;
+                    return [4 /*yield*/, api.post(t, { name: 'noam honig', myId: 1 })];
+                case 2:
+                    _b.sent();
+                    expect(entityWithValidations_1.entityWithValidations.savingRowCount).toBe(1);
+                    d.test();
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAllDbs("get array works with filter in body", async ({ createData, remult }) => {
-    let c = await createData(async (i) => {
-        await i(1, 'noam', undefined, Status.open);
-        await i(2, 'yael', undefined, Status.closed);
-        await i(3, 'yoni', undefined, Status.hold);
-    });
-    var api = new DataApi(c, remult);
-    let t = new TestDataApiResponse();
-    let d = new Done();
-    t.success = data => {
-        expect(data.length).toBe(2);
-        expect(data[0].id).toBe(2);
-        expect(data[1].id).toBe(3);
-        d.ok();
-    };
-    await api.getArray(t, {
-        get: x => {
-            return undefined;
-        }
-    }, {
-        status_in: '[1, 2]'
-    });
-    d.test();
+db_tests_setup_1.testAllDbs("get array works with filter in body", function (_a) {
+    var createData = _a.createData, remult = _a.remult;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, api, t, d;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createData(function (i) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, i(1, 'noam', undefined, models_1.Status.open)];
+                                case 1:
+                                    _a.sent();
+                                    return [4 /*yield*/, i(2, 'yael', undefined, models_1.Status.closed)];
+                                case 2:
+                                    _a.sent();
+                                    return [4 /*yield*/, i(3, 'yoni', undefined, models_1.Status.hold)];
+                                case 3:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+                case 1:
+                    c = _b.sent();
+                    api = new data_api_1.DataApi(c, remult);
+                    t = new TestDataApiResponse_1.TestDataApiResponse();
+                    d = new Done_1.Done();
+                    t.success = function (data) {
+                        expect(data.length).toBe(2);
+                        expect(data[0].id).toBe(2);
+                        expect(data[1].id).toBe(3);
+                        d.ok();
+                    };
+                    return [4 /*yield*/, api.getArray(t, {
+                            get: function (x) {
+                                return undefined;
+                            }
+                        }, {
+                            status_in: '[1, 2]'
+                        })];
+                case 2:
+                    _b.sent();
+                    d.test();
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAllDbs("entity order by works", async ({ createData }) => {
-    let type = class extends newCategories {
-    };
-    Entity('', {
-        defaultOrderBy: { categoryName: "asc" },
-    })(type);
-    let c = await createData(async (insert) => {
-        await insert(1, 'noam');
-        await insert(2, "yoni");
-        await insert(3, "yael");
-    }, type);
-    var x = await c.find();
-    expect(x[0].id).toBe(1);
-    expect(x[1].id).toBe(3);
-    expect(x[2].id).toBe(2);
-    var x = await c.find({ orderBy: {} });
-    expect(x[0].id).toBe(1);
-    expect(x[1].id).toBe(3);
-    expect(x[2].id).toBe(2);
-    var x = (await c.query({ orderBy: {}, pageSize: 100 }).paginator()).items;
-    expect(x[0].id).toBe(1);
-    expect(x[1].id).toBe(3);
-    expect(x[2].id).toBe(2);
+db_tests_setup_1.testAllDbs("entity order by works", function (_a) {
+    var createData = _a.createData;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var type, c, x, x, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    type = /** @class */ (function (_super) {
+                        tslib_1.__extends(type, _super);
+                        function type() {
+                            return _super !== null && _super.apply(this, arguments) || this;
+                        }
+                        return type;
+                    }(remult_3_entities_1.Categories));
+                    remult3_1.Entity('', {
+                        defaultOrderBy: { categoryName: "asc" },
+                    })(type);
+                    return [4 /*yield*/, createData(function (insert) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, insert(1, 'noam')];
+                                    case 1:
+                                        _a.sent();
+                                        return [4 /*yield*/, insert(2, "yoni")];
+                                    case 2:
+                                        _a.sent();
+                                        return [4 /*yield*/, insert(3, "yael")];
+                                    case 3:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }, type)];
+                case 1:
+                    c = _b.sent();
+                    return [4 /*yield*/, c.find()];
+                case 2:
+                    x = _b.sent();
+                    expect(x[0].id).toBe(1);
+                    expect(x[1].id).toBe(3);
+                    expect(x[2].id).toBe(2);
+                    return [4 /*yield*/, c.find({ orderBy: {} })];
+                case 3:
+                    x = _b.sent();
+                    expect(x[0].id).toBe(1);
+                    expect(x[1].id).toBe(3);
+                    expect(x[2].id).toBe(2);
+                    return [4 /*yield*/, c.query({ orderBy: {}, pageSize: 100 }).paginator()];
+                case 4:
+                    x = (_b.sent()).items;
+                    expect(x[0].id).toBe(1);
+                    expect(x[1].id).toBe(3);
+                    expect(x[2].id).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAllDbs("put with validation works", async ({ createData, remult }) => {
-    let count = 0;
-    let type = class extends newCategories {
-    };
-    Entity(undefined, {
-        allowApiCrud: true,
-        saving: () => {
-            if (!testConfiguration.restDbRunningOnServer)
-                count++;
-        }
-    })(type);
-    let c = await createData(async (insert) => await insert(1, 'noam'), type);
-    var api = new DataApi(c, remult);
-    let t = new TestDataApiResponse();
-    let d = new Done();
-    t.success = async (data) => {
-        d.ok();
-    };
-    count = 0;
-    await api.put(t, 1, {
-        categoryName: 'noam 1'
-    });
-    d.test();
-    var x = await c.find({
-        where: { id: 1 }
-    });
-    expect(x[0].categoryName).toBe('noam 1');
-    expect(count).toBe(1);
+db_tests_setup_1.testAllDbs("put with validation works", function (_a) {
+    var createData = _a.createData, remult = _a.remult;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var count, type, c, api, t, d, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    count = 0;
+                    type = /** @class */ (function (_super) {
+                        tslib_1.__extends(type, _super);
+                        function type() {
+                            return _super !== null && _super.apply(this, arguments) || this;
+                        }
+                        return type;
+                    }(remult_3_entities_1.Categories));
+                    remult3_1.Entity(undefined, {
+                        allowApiCrud: true,
+                        saving: function () {
+                            if (!entityWithValidations_1.testConfiguration.restDbRunningOnServer)
+                                count++;
+                        }
+                    })(type);
+                    return [4 /*yield*/, createData(function (insert) { return tslib_1.__awaiter(void 0, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, insert(1, 'noam')];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        }); }); }, type)];
+                case 1:
+                    c = _b.sent();
+                    api = new data_api_1.DataApi(c, remult);
+                    t = new TestDataApiResponse_1.TestDataApiResponse();
+                    d = new Done_1.Done();
+                    t.success = function (data) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            d.ok();
+                            return [2 /*return*/];
+                        });
+                    }); };
+                    count = 0;
+                    return [4 /*yield*/, api.put(t, 1, {
+                            categoryName: 'noam 1'
+                        })];
+                case 2:
+                    _b.sent();
+                    d.test();
+                    return [4 /*yield*/, c.find({
+                            where: { id: 1 }
+                        })];
+                case 3:
+                    x = _b.sent();
+                    expect(x[0].categoryName).toBe('noam 1');
+                    expect(count).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("saves correctly to db", async ({ createEntity }) => {
-    let type = class extends EntityBase {
-        constructor() {
-            super(...arguments);
-            this.ok = false;
-        }
-    };
-    Entity('asdf', { allowApiCrud: true })(type);
-    Fields.number()(type.prototype, 'id');
-    Fields.boolean()(type.prototype, "ok");
-    let r = (await createEntity(type)).create();
-    r.id = 1;
-    r.ok = true;
-    await r._.save();
-    expect(r.ok).toBe(true);
-    r.ok = false;
-    await r._.save();
-    expect(r.ok).toBe(false);
+db_tests_setup_1.testAll("saves correctly to db", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var type, r;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    type = /** @class */ (function (_super) {
+                        tslib_1.__extends(class_3, _super);
+                        function class_3() {
+                            var _this = _super !== null && _super.apply(this, arguments) || this;
+                            _this.ok = false;
+                            return _this;
+                        }
+                        return class_3;
+                    }(remult3_1.EntityBase));
+                    remult3_1.Entity('asdf', { allowApiCrud: true })(type);
+                    remult3_1.Fields.number()(type.prototype, 'id');
+                    remult3_1.Fields.boolean()(type.prototype, "ok");
+                    return [4 /*yield*/, createEntity(type)];
+                case 1:
+                    r = (_b.sent()).create();
+                    r.id = 1;
+                    r.ok = true;
+                    return [4 /*yield*/, r._.save()];
+                case 2:
+                    _b.sent();
+                    expect(r.ok).toBe(true);
+                    r.ok = false;
+                    return [4 /*yield*/, r._.save()];
+                case 3:
+                    _b.sent();
+                    expect(r.ok).toBe(false);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-let autoIncrement = class autoIncrement extends EntityBase {
-};
-__decorate([
-    Fields.autoIncrement(),
-    __metadata("design:type", Number)
-], autoIncrement.prototype, "id", void 0);
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], autoIncrement.prototype, "stam", void 0);
-autoIncrement = __decorate([
-    Entity("autoi", { allowApiCrud: true })
-], autoIncrement);
-testAll("auto increment can't be affected by insert or update", async ({ createEntity }) => {
-    let repo = await createEntity(autoIncrement);
-    let r = await repo.create({ id: 1234, stam: 1 }).save();
-    let x = r.id;
-    expect(x == 1234).toBe(false);
-    r.id = 4321;
-    await r.save();
-    expect(r.id).toBe(x);
+var autoIncrement = /** @class */ (function (_super) {
+    tslib_1.__extends(autoIncrement, _super);
+    function autoIncrement() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.autoIncrement(),
+        tslib_1.__metadata("design:type", Number)
+    ], autoIncrement.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], autoIncrement.prototype, "stam", void 0);
+    autoIncrement = tslib_1.__decorate([
+        remult3_1.Entity("autoi", { allowApiCrud: true })
+    ], autoIncrement);
+    return autoIncrement;
+}(remult3_1.EntityBase));
+db_tests_setup_1.testAll("auto increment can't be affected by insert or update", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, r, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(autoIncrement)];
+                case 1:
+                    repo = _b.sent();
+                    return [4 /*yield*/, repo.create({ id: 1234, stam: 1 }).save()];
+                case 2:
+                    r = _b.sent();
+                    x = r.id;
+                    expect(x == 1234).toBe(false);
+                    r.id = 4321;
+                    return [4 /*yield*/, r.save()];
+                case 3:
+                    _b.sent();
+                    expect(r.id).toBe(x);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("Paging", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({ limit: 3, orderBy: { myId: "asc" } })).length).toBe(3);
-    expect((await s.find({ limit: 3, orderBy: { myId: "asc" }, page: 2 })).length).toBe(1);
+db_tests_setup_1.testAll("Paging", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _d.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ limit: 3, orderBy: { myId: "asc" } })];
+                case 2:
+                    _b.apply(void 0, [(_d.sent()).length]).toBe(3);
+                    _c = expect;
+                    return [4 /*yield*/, s.find({ limit: 3, orderBy: { myId: "asc" }, page: 2 })];
+                case 3:
+                    _c.apply(void 0, [(_d.sent()).length]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("filter", async ({ createEntity }) => {
-    const s = await createEntity(testFilter);
-    await s.insert({ id: 1, a: 'a', b: 'b', c: 'c' });
-    expect(await s.count({
-        a: 'z',
-        $and: [testFilter.search('')]
-    })).toBe(0);
+db_tests_setup_1.testAll("filter", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(testFilter)];
+                case 1:
+                    s = _c.sent();
+                    return [4 /*yield*/, s.insert({ id: 1, a: 'a', b: 'b', c: 'c' })];
+                case 2:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.count({
+                            a: 'z',
+                            $and: [testFilter.search('')]
+                        })];
+                case 3:
+                    _b.apply(void 0, [_c.sent()]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-testAll("large string field", async ({ createEntity }) => {
-    const s = await createEntity(stam);
-    await s.insert({ title: "1234567890".repeat(100) });
-    const r = await s.findFirst();
-    expect(r.title).toBe("1234567890".repeat(100));
+db_tests_setup_1.testAll("large string field", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, r;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(stam)];
+                case 1:
+                    s = _b.sent();
+                    return [4 /*yield*/, s.insert({ title: "1234567890".repeat(100) })];
+                case 2:
+                    _b.sent();
+                    return [4 /*yield*/, s.findFirst()];
+                case 3:
+                    r = _b.sent();
+                    expect(r.title).toBe("1234567890".repeat(100));
+                    return [2 /*return*/];
+            }
+        });
+    });
 }, false);
-let testFilter = class testFilter {
-    constructor() {
+var testFilter = /** @class */ (function () {
+    function testFilter() {
         this.id = 0;
         this.a = '';
         this.b = '';
         this.c = '';
     }
-};
-testFilter.search = Filter.createCustom((remult, str) => ({
-    $and: [{
-            $or: [
-                { a: 'a' },
-                { b: 'a' },
-                { c: 'a' }
-            ]
-        }]
-}));
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], testFilter.prototype, "id", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], testFilter.prototype, "a", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], testFilter.prototype, "b", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], testFilter.prototype, "c", void 0);
-testFilter = __decorate([
-    Entity("testfilter", { allowApiCrud: true })
-], testFilter);
-let testStringWithNull = class testStringWithNull extends EntityBase {
-    constructor() {
-        super(...arguments);
-        this.id = 0;
+    testFilter.search = filter_interfaces_1.Filter.createCustom(function (remult, str) { return ({
+        $and: [{
+                $or: [
+                    { a: 'a' },
+                    { b: 'a' },
+                    { c: 'a' }
+                ]
+            }]
+    }); });
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], testFilter.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], testFilter.prototype, "a", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], testFilter.prototype, "b", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], testFilter.prototype, "c", void 0);
+    testFilter = tslib_1.__decorate([
+        remult3_1.Entity("testfilter", { allowApiCrud: true })
+    ], testFilter);
+    return testFilter;
+}());
+var testStringWithNull = /** @class */ (function (_super) {
+    tslib_1.__extends(testStringWithNull, _super);
+    function testStringWithNull() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = 0;
+        return _this;
     }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], testStringWithNull.prototype, "id", void 0);
-__decorate([
-    Fields.string({ allowNull: true }),
-    __metadata("design:type", String)
-], testStringWithNull.prototype, "d", void 0);
-testStringWithNull = __decorate([
-    Entity('teststringWithNull', { allowApiCrud: true })
-], testStringWithNull);
-let stam = class stam extends EntityBase {
-    constructor() {
-        super(...arguments);
-        this.id = 0;
-        this.title = '';
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], testStringWithNull.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string({ allowNull: true }),
+        tslib_1.__metadata("design:type", String)
+    ], testStringWithNull.prototype, "d", void 0);
+    testStringWithNull = tslib_1.__decorate([
+        remult3_1.Entity('teststringWithNull', { allowApiCrud: true })
+    ], testStringWithNull);
+    return testStringWithNull;
+}(remult3_1.EntityBase));
+var stam = /** @class */ (function (_super) {
+    tslib_1.__extends(stam, _super);
+    function stam() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = 0;
+        _this.title = '';
+        return _this;
     }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], stam.prototype, "id", void 0);
-__decorate([
-    Fields.string({ maxLength: 1500 }),
-    __metadata("design:type", String)
-], stam.prototype, "title", void 0);
-stam = __decorate([
-    Entity("a", { allowApiCrud: true })
-], stam);
-export { stam };
-let p = class p extends EntityBase {
-    constructor(remult) {
-        super();
-        this.remult = remult;
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], stam.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string({ maxLength: 1500 }),
+        tslib_1.__metadata("design:type", String)
+    ], stam.prototype, "title", void 0);
+    stam = tslib_1.__decorate([
+        remult3_1.Entity("a", { allowApiCrud: true })
+    ], stam);
+    return stam;
+}(remult3_1.EntityBase));
+exports.stam = stam;
+var p = /** @class */ (function (_super) {
+    tslib_1.__extends(p, _super);
+    function p(remult) {
+        var _this = _super.call(this) || this;
+        _this.remult = remult;
+        return _this;
     }
-};
-__decorate([
-    Fields.integer(),
-    __metadata("design:type", Number)
-], p.prototype, "id", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], p.prototype, "name", void 0);
-__decorate([
-    Field(() => c),
-    __metadata("design:type", c)
-], p.prototype, "c", void 0);
-p = __decorate([
-    Entity('p', { allowApiCrud: true }),
-    __metadata("design:paramtypes", [Remult])
-], p);
-let tasksWithEnum = class tasksWithEnum extends IdEntity {
-    constructor() {
-        super(...arguments);
-        this.title = '';
-        this.completed = false;
-        this.priority = Priority.Low;
+    tslib_1.__decorate([
+        remult3_1.Fields.integer(),
+        tslib_1.__metadata("design:type", Number)
+    ], p.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], p.prototype, "name", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(function () { return c_1.c; }),
+        tslib_1.__metadata("design:type", c_1.c)
+    ], p.prototype, "c", void 0);
+    p = tslib_1.__decorate([
+        remult3_1.Entity('p', { allowApiCrud: true }),
+        tslib_1.__metadata("design:paramtypes", [context_1.Remult])
+    ], p);
+    return p;
+}(remult3_1.EntityBase));
+var tasksWithEnum = /** @class */ (function (_super) {
+    tslib_1.__extends(tasksWithEnum, _super);
+    function tasksWithEnum() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.title = '';
+        _this.completed = false;
+        _this.priority = Priority.Low;
+        return _this;
     }
-};
-__decorate([
-    Fields.string(),
-    __metadata("design:type", Object)
-], tasksWithEnum.prototype, "title", void 0);
-__decorate([
-    Fields.boolean(),
-    __metadata("design:type", Object)
-], tasksWithEnum.prototype, "completed", void 0);
-__decorate([
-    Fields.object(),
-    __metadata("design:type", Object)
-], tasksWithEnum.prototype, "priority", void 0);
-tasksWithEnum = __decorate([
-    Entity('tasksWithEnum', {
-        allowApiCrud: true
-    })
-], tasksWithEnum);
-export { tasksWithEnum };
-export var Priority;
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithEnum.prototype, "title", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithEnum.prototype, "completed", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.object(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithEnum.prototype, "priority", void 0);
+    tasksWithEnum = tslib_1.__decorate([
+        remult3_1.Entity('tasksWithEnum', {
+            allowApiCrud: true
+        })
+    ], tasksWithEnum);
+    return tasksWithEnum;
+}(id_entity_1.IdEntity));
+exports.tasksWithEnum = tasksWithEnum;
+var Priority;
 (function (Priority) {
     Priority[Priority["Low"] = 0] = "Low";
     Priority[Priority["High"] = 1] = "High";
     Priority[Priority["Critical"] = 2] = "Critical";
-})(Priority || (Priority = {}));
-testAll("task with enum", async ({ createEntity }) => {
-    const r = await createEntity(tasksWithEnum);
-    await r.insert({
-        title: 'a',
-        priority: Priority.Critical
-    });
-    const item = await r.findFirst();
-    expect(item.priority).toBe(Priority.Critical);
-    expect(await r.count({ priority: Priority.Critical })).toBe(1);
-    expect(await r.count({ priority: Priority.Low })).toBe(0);
+})(Priority = exports.Priority || (exports.Priority = {}));
+db_tests_setup_1.testAll("task with enum", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, item, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createEntity(tasksWithEnum)];
+                case 1:
+                    r = _d.sent();
+                    return [4 /*yield*/, r.insert({
+                            title: 'a',
+                            priority: Priority.Critical
+                        })];
+                case 2:
+                    _d.sent();
+                    return [4 /*yield*/, r.findFirst()];
+                case 3:
+                    item = _d.sent();
+                    expect(item.priority).toBe(Priority.Critical);
+                    _b = expect;
+                    return [4 /*yield*/, r.count({ priority: Priority.Critical })];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toBe(1);
+                    _c = expect;
+                    return [4 /*yield*/, r.count({ priority: Priority.Low })];
+                case 5:
+                    _c.apply(void 0, [_d.sent()]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-let tasksWithStringEnum = class tasksWithStringEnum extends IdEntity {
-    constructor() {
-        super(...arguments);
-        this.title = '';
-        this.completed = false;
-        this.priority = PriorityWithString.Low;
+var tasksWithStringEnum = /** @class */ (function (_super) {
+    tslib_1.__extends(tasksWithStringEnum, _super);
+    function tasksWithStringEnum() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.title = '';
+        _this.completed = false;
+        _this.priority = PriorityWithString.Low;
+        return _this;
     }
-};
-__decorate([
-    Fields.string(),
-    __metadata("design:type", Object)
-], tasksWithStringEnum.prototype, "title", void 0);
-__decorate([
-    Fields.boolean(),
-    __metadata("design:type", Object)
-], tasksWithStringEnum.prototype, "completed", void 0);
-__decorate([
-    Fields.object(),
-    __metadata("design:type", Object)
-], tasksWithStringEnum.prototype, "priority", void 0);
-tasksWithStringEnum = __decorate([
-    Entity('tasksWithStringEnum', {
-        allowApiCrud: true
-    })
-], tasksWithStringEnum);
-export { tasksWithStringEnum };
-export var PriorityWithString;
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithStringEnum.prototype, "title", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithStringEnum.prototype, "completed", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.object(),
+        tslib_1.__metadata("design:type", Object)
+    ], tasksWithStringEnum.prototype, "priority", void 0);
+    tasksWithStringEnum = tslib_1.__decorate([
+        remult3_1.Entity('tasksWithStringEnum', {
+            allowApiCrud: true
+        })
+    ], tasksWithStringEnum);
+    return tasksWithStringEnum;
+}(id_entity_1.IdEntity));
+exports.tasksWithStringEnum = tasksWithStringEnum;
+var PriorityWithString;
 (function (PriorityWithString) {
     PriorityWithString["Low"] = "Low";
     PriorityWithString["High"] = "High";
     PriorityWithString["Critical"] = "Critical";
-})(PriorityWithString || (PriorityWithString = {}));
-testAll("task with enum string", async ({ createEntity }) => {
-    const r = await createEntity(tasksWithStringEnum);
-    await r.insert({
-        title: 'a',
-        priority: PriorityWithString.Critical
-    });
-    const item = await r.findFirst();
-    expect(item.priority).toBe(PriorityWithString.Critical);
-    expect(await r.count({ priority: PriorityWithString.Critical })).toBe(1);
-    expect(await r.count({ priority: PriorityWithString.Low })).toBe(0);
+})(PriorityWithString = exports.PriorityWithString || (exports.PriorityWithString = {}));
+db_tests_setup_1.testAll("task with enum string", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, item, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createEntity(tasksWithStringEnum)];
+                case 1:
+                    r = _d.sent();
+                    return [4 /*yield*/, r.insert({
+                            title: 'a',
+                            priority: PriorityWithString.Critical
+                        })];
+                case 2:
+                    _d.sent();
+                    return [4 /*yield*/, r.findFirst()];
+                case 3:
+                    item = _d.sent();
+                    expect(item.priority).toBe(PriorityWithString.Critical);
+                    _b = expect;
+                    return [4 /*yield*/, r.count({ priority: PriorityWithString.Critical })];
+                case 4:
+                    _b.apply(void 0, [_d.sent()]).toBe(1);
+                    _c = expect;
+                    return [4 /*yield*/, r.count({ priority: PriorityWithString.Low })];
+                case 5:
+                    _c.apply(void 0, [_d.sent()]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
 });
-testAll("test transaction rollback", async ({ db }) => {
-    let fail = true;
-    try {
-        await db.transaction(async () => {
-            throw "error";
+db_tests_setup_1.testAll("test transaction rollback", function (_a) {
+    var db = _a.db;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var fail, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    fail = true;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, db.transaction(function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                throw "error";
+                            });
+                        }); })];
+                case 2:
+                    _c.sent();
+                    fail = false;
+                    return [3 /*break*/, 4];
+                case 3:
+                    _b = _c.sent();
+                    return [3 /*break*/, 4];
+                case 4:
+                    expect(fail).toBe(true);
+                    return [2 /*return*/];
+            }
         });
-        fail = false;
-    }
-    catch {
-    }
-    expect(fail).toBe(true);
+    });
 });