remult 0.9.7 → 0.9.11

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

@@ -0,0 +1,1228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+db_tests_setup_1.testAll("what", function (_a) {
+    var remult = _a.remult, createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(stam)];
+                case 1: return [4 /*yield*/, (_c.sent()).create({ id: 1, title: 'noam' }).save()];
+                case 2:
+                    _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, remult.repo(stam).count()];
+                case 3:
+                    _b.apply(void 0, [_c.sent()]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("filter works on all db", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { myId: [1, 3] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("test empty in", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { myId: [] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("filter works on all db or", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, entityWithValidations_1.entityWithValidations.create4RowsInDp(createEntity)];
+                case 1:
+                    s = _c.sent();
+                    _b = expect;
+                    return [4 /*yield*/, s.find({ where: { $or: [{ myId: 1 }, { myId: 3 }] } })];
+                case 2:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+db_tests_setup_1.testAll("entity with different id column still works well", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var s, c, _b;
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
+                case 0: return [4 /*yield*/, createEntity(entityWithValidations_1.entityWithValidations)];
+                case 1:
+                    s = _c.sent();
+                    c = s.create();
+                    c.myId = 1;
+                    c.name = 'noam';
+                    return [4 /*yield*/, c._.save()];
+                case 2:
+                    _c.sent();
+                    c.name = 'yael';
+                    return [4 /*yield*/, c._.save()];
+                case 3:
+                    _c.sent();
+                    expect(c.name).toBe('yael');
+                    _b = expect;
+                    return [4 /*yield*/, s.find()];
+                case 4:
+                    _b.apply(void 0, [(_c.sent()).length]).toBe(1);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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;
+    }
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        tslib_1.__metadata("design:type", Number)
+    ], testDateWithNull.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.DateOnlyField({ 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*/];
+            }
+        });
+    });
+});
+db_tests_setup_1.testAll("test tasks", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, t, _b, _c, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
+                case 0: return [4 /*yield*/, createEntity(tasks_1.tasks)];
+                case 1:
+                    c = _e.sent();
+                    t = c.create();
+                    t.id = 1;
+                    return [4 /*yield*/, t._.save()];
+                case 2:
+                    _e.sent();
+                    t = c.create();
+                    t.id = 2;
+                    t.completed = true;
+                    return [4 /*yield*/, t._.save()];
+                case 3:
+                    _e.sent();
+                    t = c.create();
+                    t.id = 3;
+                    t.completed = true;
+                    return [4 /*yield*/, t._.save()];
+                case 4:
+                    _e.sent();
+                    return [4 /*yield*/, c.create({ id: 4, completed: false }).save()];
+                case 5:
+                    _e.sent();
+                    _b = expect;
+                    return [4 /*yield*/, c.count({ completed: false })];
+                case 6:
+                    _b.apply(void 0, [_e.sent()]).toBe(2);
+                    _c = expect;
+                    return [4 /*yield*/, c.count({ completed: { $ne: true } })];
+                case 7:
+                    _c.apply(void 0, [_e.sent()]).toBe(2);
+                    _d = expect;
+                    return [4 /*yield*/, c.count({ completed: true })];
+                case 8:
+                    _d.apply(void 0, [_e.sent()]).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+db_tests_setup_1.testAllDbs("test filter packer", function (_a) {
+    var insertFourRows = _a.insertFourRows;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, rows;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, insertFourRows()];
+                case 1:
+                    r = _b.sent();
+                    return [4 /*yield*/, r.find()];
+                case 2:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(4);
+                    return [4 /*yield*/, r.find({
+                            where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { description: 'x' }))
+                        })];
+                case 3:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(2);
+                    return [4 /*yield*/, r.find({ where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { id: 4 })) })];
+                case 4:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(1);
+                    expect(rows[0].categoryName).toBe('yael');
+                    return [4 /*yield*/, r.find({ where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { description: 'y', categoryName: 'yoni' })) })];
+                case 5:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(1);
+                    expect(rows[0].id).toBe(2);
+                    return [4 /*yield*/, r.find({ where: filter_interfaces_1.Filter.entityFilterFromJson(r.metadata, filter_interfaces_1.entityFilterToJson(r.metadata, { id: { $ne: [2, 4] } })) })];
+                case 6:
+                    rows = _b.sent();
+                    expect(rows.length).toBe(2);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+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.Field({
+                        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.Field({
+                        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*/];
+            }
+        });
+    });
+});
+var testNumbers = /** @class */ (function (_super) {
+    tslib_1.__extends(testNumbers, _super);
+    function testNumbers() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        remult3_1.IntegerField(),
+        tslib_1.__metadata("design:type", Number)
+    ], testNumbers.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        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*/];
+            }
+        });
+    });
+});
+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*/];
+            }
+        });
+    });
+});
+db_tests_setup_1.testAllDbs("get array works with filter in body", function (_a) {
+    var createData = _a.createData, remult = _a.remult;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var c, api, t, d;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createData(function (i) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, i(1, 'noam', undefined, models_1.Status.open)];
+                                case 1:
+                                    _a.sent();
+                                    return [4 /*yield*/, i(2, 'yael', undefined, models_1.Status.closed)];
+                                case 2:
+                                    _a.sent();
+                                    return [4 /*yield*/, i(3, 'yoni', undefined, models_1.Status.hold)];
+                                case 3:
+                                    _a.sent();
+                                    return [2 /*return*/];
+                            }
+                        });
+                    }); })];
+                case 1:
+                    c = _b.sent();
+                    api = new data_api_1.DataApi(c, remult);
+                    t = new TestDataApiResponse_1.TestDataApiResponse();
+                    d = new Done_1.Done();
+                    t.success = function (data) {
+                        expect(data.length).toBe(2);
+                        expect(data[0].id).toBe(2);
+                        expect(data[1].id).toBe(3);
+                        d.ok();
+                    };
+                    return [4 /*yield*/, api.getArray(t, {
+                            get: function (x) {
+                                return undefined;
+                            }
+                        }, {
+                            status_in: '[1, 2]'
+                        })];
+                case 2:
+                    _b.sent();
+                    d.test();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+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;
+        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 [2 /*return*/];
+            }
+        });
+    });
+}, 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*/];
+            }
+        });
+    });
+});
+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.Field({
+                        valueType: Number
+                    })(type.prototype, 'id');
+                    remult3_1.Field({ valueType: 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*/];
+            }
+        });
+    });
+});
+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.IntegerField(),
+        tslib_1.__metadata("design:type", Number)
+    ], autoIncrement.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.IntegerField(),
+        tslib_1.__metadata("design:type", Number)
+    ], autoIncrement.prototype, "stam", void 0);
+    autoIncrement = tslib_1.__decorate([
+        remult3_1.Entity("autoi", { allowApiCrud: true, dbAutoIncrementId: true })
+    ], autoIncrement);
+    return autoIncrement;
+}(remult3_1.EntityBase));
+db_tests_setup_1.testAll("auto increment can't be affected by insert or update", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var repo, r, x;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, createEntity(autoIncrement)];
+                case 1:
+                    repo = _b.sent();
+                    return [4 /*yield*/, repo.create({ id: 1234, stam: 1 }).save()];
+                case 2:
+                    r = _b.sent();
+                    x = r.id;
+                    expect(x == 1234).toBe(false);
+                    r.id = 4321;
+                    return [4 /*yield*/, r.save()];
+                case 3:
+                    _b.sent();
+                    expect(r.id).toBe(x);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);
+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;
+    }
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        tslib_1.__metadata("design:type", Number)
+    ], testStringWithNull.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field({ 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;
+    }
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        tslib_1.__metadata("design:type", Number)
+    ], stam.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        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;
+    }
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        tslib_1.__metadata("design:type", Number)
+    ], p.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        tslib_1.__metadata("design:type", String)
+    ], p.prototype, "name", void 0);
+    tslib_1.__decorate([
+        remult3_1.Field(),
+        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));
+//# sourceMappingURL=db-tests.db-tests.js.map