remult 0.14.2 → 0.14.5

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

@@ -1,1629 +1,723 @@
-"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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+testAll("test empty in", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { myId: [] } })).length).toBe(0);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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');
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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');
 }, false);
-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("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("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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 });
-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;
+let testDateWithNull = class testDateWithNull extends EntityBase {
+    constructor() {
+        super(...arguments);
+        this.id = 0;
     }
-    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*/];
-            }
-        });
-    });
+};
+__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();
 });
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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", 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_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 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 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(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(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 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 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("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("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*/];
-            }
-        });
-    });
+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.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*/];
-            }
-        });
-    });
+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');
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, 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*/];
-            }
-        });
-    });
-});
-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*/];
-            }
-        });
-    });
+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);
 });
-var testNumbers = /** @class */ (function (_super) {
-    tslib_1.__extends(testNumbers, _super);
-    function testNumbers() {
-        return _super !== null && _super.apply(this, arguments) || this;
+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;
     }
-    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*/];
-            }
-        });
-    });
+    catch (err) {
+        expect(cat._.fields.a.error).toEqual("already exists");
+    }
+    expect(saved).toBe(false);
 });
-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*/];
-            }
-        });
-    });
+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);
 });
-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*/];
-            }
-        });
-    });
+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();
+});
+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();
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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.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*/];
-            }
-        });
-    });
+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);
 });
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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);
 }, false);
-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*/];
-            }
-        });
-    });
+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));
 }, false);
-var testFilter = /** @class */ (function () {
-    function testFilter() {
+let testFilter = class testFilter {
+    constructor() {
         this.id = 0;
         this.a = '';
         this.b = '';
         this.c = '';
     }
-    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;
+};
+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;
     }
-    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)
+], 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)
-    ], 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)
+], 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)
-    ], 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.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.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;
+};
+__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;
 (function (Priority) {
     Priority[Priority["Low"] = 0] = "Low";
     Priority[Priority["High"] = 1] = "High";
     Priority[Priority["Critical"] = 2] = "Critical";
-})(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*/];
-            }
-        });
-    });
+})(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);
 });
-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;
+let tasksWithStringEnum = class tasksWithStringEnum extends IdEntity {
+    constructor() {
+        super(...arguments);
+        this.title = '';
+        this.completed = false;
+        this.priority = PriorityWithString.Low;
     }
-    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;
+};
+__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;
 (function (PriorityWithString) {
     PriorityWithString["Low"] = "Low";
     PriorityWithString["High"] = "High";
     PriorityWithString["Critical"] = "Critical";
-})(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*/];
-            }
-        });
-    });
+})(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);
 });
-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*/];
-            }
+testAll("test transaction rollback", async ({ db }) => {
+    let fail = true;
+    try {
+        await db.transaction(async () => {
+            throw "error";
         });
-    });
+        fail = false;
+    }
+    catch {
+    }
+    expect(fail).toBe(true);
 });