remult 0.22.3 → 0.22.5

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

@@ -0,0 +1,810 @@
+import { DataApi } from "../data-api";
+import { Fields, Entity, EntityBase, Field, IdEntity } 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, TestDbs } 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 { entityForrawFilter1 } from "../tests/entityForCustomFilter";
+import { entityWithValidationsOnColumn } from "../tests/entityWithValidationsOnColumn";
+import { Validators } from "../validators";
+import { Status } from "../tests/testModel/models";
+import { describeClass } from "../remult3/DecoratorReplacer";
+import { DataProviderLiveQueryStorage, LiveQueryStorageEntity } from "../../live-query/data-provider-live-query-storage";
+import { v4 as uuid } from 'uuid';
+testAll("what", async ({ remult, createEntity }) => {
+    await (await createEntity(stam)).create({ id: 1, title: 'noam' }).save();
+    expect(await remult.repo(stam).count()).toBe(1);
+}, false);
+testAll("data types", async ({ remult, createEntity }) => {
+    let r = await (await createEntity(stam)).create({
+        id: 1,
+        //@ts-ignore
+        title: 42
+    }).save();
+    expect(r.title).toEqual("42");
+}, false);
+testAll("filter works on all db", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { myId: [1, 3] } })).length).toBe(2);
+}, false);
+testAll("test in statement and ", async ({ createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    expect(await repo.count({ myId: [1, 3], $and: [{ myId: [3] }] })).toBe(1);
+}, false);
+testAll("filter with and", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { $and: [{ myId: 1 }, { myId: 3 }] } })).length).toBe(0);
+}, false);
+testAll("test empty in", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { myId: [] } })).length).toBe(0);
+}, false);
+testAll("filter works on all db or", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { $or: [{ myId: 1 }, { myId: 3 }] } })).length).toBe(2);
+}, false);
+testAll("filter works on all db or_1", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { $or: [{}, {}] } })).length).toBe(4);
+}, false);
+testAll("filter works on all db or_2", async ({ createEntity }) => {
+    let s = await entityWithValidations.create4RowsInDp(createEntity);
+    expect((await s.find({ where: { $or: [{}, { myId: 3 }] } })).length).toBe(4);
+}, false);
+testAll("entity with different id column still works well", async ({ createEntity }) => {
+    let s = await createEntity(entityWithValidations);
+    let c = s.create();
+    c.myId = 1;
+    c.name = 'noam';
+    await c._.save();
+    c.name = 'yael';
+    await c._.save();
+    expect(c.name).toBe('yael');
+    expect((await s.find()).length).toBe(1);
+}, false);
+testAll("empty find works", async ({ remult, createEntity }) => {
+    let c = (await createEntity(newCategories)).create();
+    c.id = 5;
+    c.categoryName = 'test';
+    await c._.save();
+    let l = await remult.repo(newCategories).find();
+    expect(l.length).toBe(1);
+    expect(l[0].categoryName).toBe('test');
+}, false);
+testAll("test descending", async ({ createEntity }) => {
+    const repo = await createEntity(newCategories);
+    await repo.create({ id: 1, categoryName: 'a' }).save();
+    await repo.create({ id: 2, categoryName: 'b' }).save();
+    const rows = await repo.find({
+        orderBy: { categoryName: 'desc' },
+        page: -1
+    });
+    expect(rows[0].id).toBe(2);
+}, false);
+testAll("test descending 2", async ({ createEntity }) => {
+    const repo = await createEntity(newCategories);
+    await repo.insert([{ id: 1, categoryName: 'a' }, { id: 2, categoryName: 'b' }]);
+    const rows = await repo.find({
+        orderBy: { categoryName: 'desc' },
+        page: -1
+    });
+    expect(rows[0].id).toBe(2);
+}, false);
+testAll("partial updates", async ({ remult, createEntity }) => {
+    let c = (await createEntity(newCategories)).create({
+        id: 5, categoryName: 'test', description: 'desc'
+    });
+    await c._.save();
+    let l = await remult.repo(newCategories).findId(5);
+    c.categoryName = 'newname';
+    l.description = 'new desc';
+    await c.save();
+    await l.save();
+    expect(l.categoryName).toBe('newname');
+    expect(l.description).toBe('new desc');
+}, false);
+testAll("put with validations on entity fails", async ({ remult, createEntity }) => {
+    let s = await createEntity(entityWithValidations);
+    let c = s.create();
+    c.myId = 1;
+    c.name = 'noam';
+    await c._.save();
+    let api = new DataApi(s, remult);
+    let t = new TestDataApiResponse();
+    let d = new Done();
+    t.error = async (data) => {
+        expect(data.modelState.name).toBe('invalid');
+        d.ok();
+    };
+    await api.put(t, 1, {
+        name: '1'
+    });
+    d.test();
+    var x = await s.find({ where: { myId: 1 } });
+    expect(x[0].name).toBe('noam');
+    x = await s.find({ where: { myId: 1 } });
+    expect(x[0].name).toBe('noam');
+});
+testAll("test date only 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);
+    r.d = new Date(1976, 5, 16);
+    await r.save();
+    expect(r.d.getFullYear()).toBe(1976);
+    r = await repo.findFirst();
+    expect(r.d.getFullYear()).toBe(1976);
+    r.d = null;
+    await r.save();
+    expect(r.d).toBeNull();
+}, false);
+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.fullDate).toBeNull("expected null after");
+    expect(await repo.count({ fullDate: null })).toBe(1);
+    r.fullDate = new Date(1976, 5, 16);
+    await r.save();
+    expect(r.fullDate.getFullYear()).toBe(1976);
+    r = await repo.findFirst();
+    expect(r.fullDate.getFullYear()).toBe(1976);
+    r.fullDate = null;
+    await r.save();
+    expect(r.fullDate).toBeNull();
+}, false);
+testAll("test original value of date", async ({ createEntity }) => {
+    let r = await (await createEntity(testDateWithNull)).create({ id: 1, d: new Date(1976, 6, 16) }).save();
+    expect(r.$.d.originalValue.getFullYear()).toBe(1976);
+});
+@Entity('testDateWithNull', { allowApiCrud: true })
+class testDateWithNull extends EntityBase {
+    @Fields.integer()
+    id = 0;
+    @Fields.dateOnly({ allowNull: true })
+    d;
+    @Fields.date({ allowNull: true })
+    fullDate = null;
+}
+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();
+});
+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);
+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);
+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);
+}, false);
+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);
+});
+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);
+});
+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);
+});
+testAll("test that it works with inheritance", async ({ createEntity }) => {
+    let c = await createEntity(entityForrawFilter1);
+    for (let id = 0; id < 5; id++) {
+        await c.create({ id }).save();
+    }
+    expect(await (c.count(entityForrawFilter1.oneAndThree()))).toBe(2);
+    expect((await (c.findFirst(entityForrawFilter1.testNumericValue(2)))).id).toBe(2);
+    expect((await (c.findFirst(entityForrawFilter1.testObjectValue({ val: 2 })))).id).toBe(2);
+});
+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');
+});
+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);
+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);
+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);
+testAll("Test unique Validation,", async ({ createEntity }) => {
+    let type = class extends newCategories {
+        a;
+    };
+    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);
+});
+testAll("Test unique Validation 2", async ({ createEntity }) => {
+    let type = class extends newCategories {
+        a;
+    };
+    Entity('sdfgds')(type);
+    Fields.string({
+        validate: Validators.unique
+    })(type.prototype, "a");
+    var c = await createEntity(type);
+    var cat = c.create();
+    cat.a = '12';
+    await cat._.save();
+    cat = c.create();
+    cat.a = '12';
+    var saved = false;
+    try {
+        await cat._.save();
+        saved = true;
+    }
+    catch (err) {
+        expect(cat._.fields.a.error).toEqual("already exists");
+    }
+    expect(saved).toBe(false);
+});
+@Entity('testNumbers', { allowApiCrud: true })
+class testNumbers extends EntityBase {
+    @Fields.integer()
+    id;
+    @Fields.number()
+    a;
+}
+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);
+});
+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);
+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);
+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);
+});
+testAll("saves correctly to db", async ({ createEntity }) => {
+    let type = class extends EntityBase {
+        id;
+        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);
+});
+@Entity("autoi", { allowApiCrud: true })
+class autoIncrement extends EntityBase {
+    @Fields.autoIncrement()
+    id;
+    @Fields.integer()
+    stam;
+}
+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);
+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);
+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);
+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);
+@Entity("testfilter", { allowApiCrud: true })
+class testFilter {
+    @Fields.integer()
+    id = 0;
+    @Fields.string()
+    a = '';
+    @Fields.string()
+    b = '';
+    @Fields.string()
+    c = '';
+    static search = Filter.createCustom((str, remult) => ({
+        $and: [{
+                $or: [
+                    { a: 'a' },
+                    { b: 'a' },
+                    { c: 'a' }
+                ]
+            }]
+    }));
+}
+@Entity('teststringWithNull', { allowApiCrud: true })
+class testStringWithNull extends EntityBase {
+    @Fields.integer()
+    id = 0;
+    @Fields.string({ allowNull: true })
+    d;
+}
+@Entity("a", { allowApiCrud: true })
+export class stam extends EntityBase {
+    @Fields.integer()
+    id = 0;
+    @Fields.string({ maxLength: 1500 })
+    title = '';
+}
+@Entity('p', { allowApiCrud: true })
+class p extends EntityBase {
+    remult;
+    @Fields.integer()
+    id;
+    @Fields.string()
+    name;
+    @Field(() => c)
+    c;
+    constructor(remult) {
+        super();
+        this.remult = remult;
+    }
+}
+@Entity('tasksWithEnum', {
+    allowApiCrud: true
+})
+export class tasksWithEnum extends IdEntity {
+    @Fields.string()
+    title = '';
+    @Fields.boolean()
+    completed = false;
+    @Fields.object()
+    priority = Priority.Low;
+}
+export var Priority;
+(function (Priority) {
+    Priority[Priority["Low"] = 0] = "Low";
+    Priority[Priority["High"] = 1] = "High";
+    Priority[Priority["Critical"] = 2] = "Critical";
+})(Priority || (Priority = {}));
+testAll("task with enum", async ({ createEntity }) => {
+    const r = await createEntity(tasksWithEnum);
+    await r.insert({
+        title: 'a',
+        priority: Priority.Critical
+    });
+    const item = await r.findFirst();
+    expect(item.priority).toBe(Priority.Critical);
+    expect(await r.count({ priority: Priority.Critical })).toBe(1);
+    expect(await r.count({ priority: Priority.Low })).toBe(0);
+});
+@Entity('tasksWithStringEnum', {
+    allowApiCrud: true
+})
+export class tasksWithStringEnum extends IdEntity {
+    @Fields.string()
+    title = '';
+    @Fields.boolean()
+    completed = false;
+    @Fields.object()
+    priority = PriorityWithString.Low;
+}
+export var PriorityWithString;
+(function (PriorityWithString) {
+    PriorityWithString["Low"] = "Low";
+    PriorityWithString["High"] = "High";
+    PriorityWithString["Critical"] = "Critical";
+})(PriorityWithString || (PriorityWithString = {}));
+testAll("task with enum string", async ({ createEntity }) => {
+    const r = await createEntity(tasksWithStringEnum);
+    await r.insert({
+        title: 'a',
+        priority: PriorityWithString.Critical
+    });
+    const item = await r.findFirst();
+    expect(item.priority).toBe(PriorityWithString.Critical);
+    expect(await r.count({ priority: PriorityWithString.Critical })).toBe(1);
+    expect(await r.count({ priority: PriorityWithString.Low })).toBe(0);
+});
+testAll("test transaction rollback", async ({ db, createEntity }) => {
+    let fail = true;
+    const r = await createEntity(stam);
+    await r.insert({ title: "task b", id: 1 });
+    try {
+        await db.transaction(async (db) => {
+            var remultWithTransaction = new Remult(db).repo(stam);
+            await remultWithTransaction.insert({ title: "task a", id: 2 });
+            expect(await remultWithTransaction.count()).toBe(2);
+            throw "error";
+        });
+        fail = false;
+    }
+    catch {
+    }
+    expect(await r.count()).toBe(1);
+    expect(fail).toBe(true);
+}, false, { exclude: [TestDbs.inMemory] });
+testAll("test date", async ({ createEntity }) => {
+    const e = class {
+        a = 0;
+        d = new Date();
+    };
+    describeClass(e, Entity("tdate", { allowApiCrud: true }), {
+        a: Fields.number(),
+        d: Fields.date()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, d: new Date(1976, 5, 16) });
+    let item = await r.findFirst();
+    expect(item.d.getFullYear()).toBe(1976);
+}, false);
+testAll("test live query storage", async ({ db, remult, createEntity }) => {
+    await createEntity(LiveQueryStorageEntity);
+    var x = new DataProviderLiveQueryStorage(db);
+    if (db.ensureSchema)
+        await x.ensureSchema();
+    const id = uuid();
+    await x.add({ id, entityKey: 'x', data: "noam" });
+    await x.forEach("x", async (args) => {
+        expect(args.query.data).toBe("noam");
+    });
+    expect((await x.keepAliveAndReturnUnknownQueryIds([id]))).toEqual([]);
+}, false, {
+    exclude: [TestDbs.restDataProvider]
+});
+testAll("test contains with names with casing", async ({ createEntity }) => {
+    const e = class {
+        a = 0;
+        firstName = '';
+    };
+    describeClass(e, Entity("testNameContains", { allowApiCrud: true }), {
+        a: Fields.number(),
+        firstName: Fields.string()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, firstName: "noam" });
+    let item = await r.findFirst({ firstName: { $contains: "oa" } });
+    expect(item.firstName).toBe("noam");
+}, false, {
+    exclude: [TestDbs.mongo]
+});
+testAll("test live query storage", async (x) => {
+    await x.createEntity(LiveQueryStorageEntity);
+    const s = new DataProviderLiveQueryStorage(x.db);
+    await s.ensureSchema();
+    const entityKey = "ek";
+    const id = 'id';
+    await s.add({ id, entityKey, data: {} });
+    await s.add({ id, entityKey, data: {} });
+    x.remult.clearAllCache();
+    await s.add({ id, entityKey, data: {} });
+    await s.keepAliveAndReturnUnknownQueryIds([id]);
+    await s.remove(id);
+    await s.remove(id);
+}, false, { exclude: [TestDbs.restDataProvider] });
+testAll("test json structure using object", async ({ createEntity }) => {
+    const e = class {
+        a = 0;
+        person;
+    };
+    describeClass(e, Entity("testJsonStructure", { allowApiCrud: true }), {
+        a: Fields.number(),
+        person: Fields.object()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, person: { firstName: "noam", lastName: "honig" } });
+    let item = await r.findFirst();
+    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+}, false);
+@Entity("testObject", { allowApiCrud: true })
+class testObject {
+    @Fields.integer()
+    id = 0;
+    @Fields.object()
+    person = { firstName: "noam", lastName: "honig" };
+}
+testAll("test object entity", async ({ createEntity }) => {
+    const r = await createEntity(testObject);
+    await r.insert({ id: 1, person: { firstName: "noam", lastName: "honig" } });
+    let item = await r.findFirst();
+    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+}, false);
+@Entity("testObjectJson", { allowApiCrud: true })
+class testObjectJson {
+    @Fields.integer()
+    id = 0;
+    @Fields.json()
+    person = { firstName: "noam", lastName: "honig" };
+}
+testAll("test object entity", async ({ createEntity }) => {
+    const r = await createEntity(testObjectJson);
+    await r.insert({ id: 1, person: { firstName: "noam", lastName: "honig" } });
+    let item = await r.findFirst();
+    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+}, false);
+testAll("test json structure", async ({ createEntity }) => {
+    const e = class {
+        a = 0;
+        person;
+    };
+    describeClass(e, Entity("testJsonFieldType", { allowApiCrud: true }), {
+        a: Fields.number(),
+        person: Fields.json()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, person: { firstName: "noam", lastName: "honig" } });
+    let item = await r.findFirst();
+    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+}, false);
+testAll("test json structure 2", async ({ createEntity }) => {
+    const e = class {
+        a = 0;
+        items = [];
+    };
+    describeClass(e, Entity("testJsonFieldType2", { allowApiCrud: true }), {
+        a: Fields.number(),
+        items: Fields.json()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, items: ["a", "b"] });
+    let item = await r.findFirst();
+    expect(item.items).toEqual(["a", "b"]);
+    //expect(await r.count({ items: { $contains: "b" } })).toBe(1)
+}, false);
+testAll("test json structure 3", async ({ createEntity }) => {
+    const e = class {
+        a = 0;
+        items = [];
+    };
+    describeClass(e, Entity("testJsonFieldType3", { allowApiCrud: true }), {
+        a: Fields.number(),
+        items: Fields.object()
+    });
+    const r = await createEntity(e);
+    await r.insert({ a: 1, items: ["a", "b"] });
+    let item = await r.findFirst();
+    expect(item.items).toEqual(["a", "b"]);
+    expect(await r.count({ items: { $contains: "b" } })).toBe(1);
+}, false, {
+    exclude: [TestDbs.mongo]
+});