remult 0.21.1 → 0.22.0

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

@@ -1,66 +1,69 @@
 import { __decorate, __metadata } from "tslib";
-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 { 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 }) => {
+import { ValueConverters } from '../valueConverters';
+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({
+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");
+        title: 42,
+    })
+        .save();
+    expect(r.title).toEqual('42');
 }, false);
-testAll("filter works on all db", async ({ createEntity }) => {
+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 }) => {
+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 }) => {
+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 }) => {
+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 }) => {
+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 }) => {
+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 }) => {
+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 }) => {
+testAll('entity with different id column still works well', async ({ createEntity }) => {
     let s = await createEntity(entityWithValidations);
     let c = s.create();
     c.myId = 1;
@@ -71,7 +74,7 @@ testAll("entity with different id column still works well", async ({ createEntit
     expect(c.name).toBe('yael');
     expect((await s.find()).length).toBe(1);
 }, false);
-testAll("empty find works", async ({ remult, createEntity }) => {
+testAll('empty find works', async ({ remult, createEntity }) => {
     let c = (await createEntity(newCategories)).create();
     c.id = 5;
     c.categoryName = 'test';
@@ -80,28 +83,33 @@ testAll("empty find works", async ({ remult, createEntity }) => {
     expect(l.length).toBe(1);
     expect(l[0].categoryName).toBe('test');
 }, false);
-testAll("test descending", async ({ createEntity }) => {
+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
+        page: -1,
     });
     expect(rows[0].id).toBe(2);
 }, false);
-testAll("test descending 2", async ({ createEntity }) => {
+testAll('test descending 2', async ({ createEntity }) => {
     const repo = await createEntity(newCategories);
-    await repo.insert([{ id: 1, categoryName: 'a' }, { id: 2, categoryName: 'b' }]);
+    await repo.insert([
+        { id: 1, categoryName: 'a' },
+        { id: 2, categoryName: 'b' },
+    ]);
     const rows = await repo.find({
         orderBy: { categoryName: 'desc' },
-        page: -1
+        page: -1,
     });
     expect(rows[0].id).toBe(2);
 }, false);
-testAll("partial updates", async ({ remult, createEntity }) => {
+testAll('partial updates', async ({ remult, createEntity }) => {
     let c = (await createEntity(newCategories)).create({
-        id: 5, categoryName: 'test', description: 'desc'
+        id: 5,
+        categoryName: 'test',
+        description: 'desc',
     });
     await c._.save();
     let l = await remult.repo(newCategories).findId(5);
@@ -112,7 +120,7 @@ testAll("partial updates", async ({ remult, createEntity }) => {
     expect(l.categoryName).toBe('newname');
     expect(l.description).toBe('new desc');
 }, false);
-testAll("put with validations on entity fails", async ({ remult, createEntity }) => {
+testAll('put with validations on entity fails', async ({ remult, createEntity }) => {
     let s = await createEntity(entityWithValidations);
     let c = s.create();
     c.myId = 1;
@@ -126,7 +134,7 @@ testAll("put with validations on entity fails", async ({ remult, createEntity })
         d.ok();
     };
     await api.put(t, 1, {
-        name: '1'
+        name: '1',
     });
     d.test();
     var x = await s.find({ where: { myId: 1 } });
@@ -134,7 +142,7 @@ testAll("put with validations on entity fails", async ({ remult, createEntity })
     x = await s.find({ where: { myId: 1 } });
     expect(x[0].name).toBe('noam');
 });
-testAll("test date only with null works", async ({ createEntity }) => {
+testAll('test date only with null works', async ({ createEntity }) => {
     let repo = await createEntity(testDateWithNull);
     let r = repo.create({ id: 0 });
     await r.save();
@@ -150,12 +158,12 @@ testAll("test date only with null works", async ({ createEntity }) => {
     await r.save();
     expect(r.d).toBeNull();
 }, false);
-testAll("test date with null works", async ({ createEntity }) => {
+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(r.fullDate).toBeNull('expected null after');
     expect(await repo.count({ fullDate: null })).toBe(1);
     r.fullDate = new Date(1976, 5, 16);
     await r.save();
@@ -166,8 +174,10 @@ testAll("test date with null works", async ({ createEntity }) => {
     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();
+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);
 });
 let testDateWithNull = class testDateWithNull extends EntityBase {
@@ -192,14 +202,14 @@ __decorate([
 testDateWithNull = __decorate([
     Entity('testDateWithNull', { allowApiCrud: true })
 ], testDateWithNull);
-testAll("test string with null works", async ({ createEntity }) => {
+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 }) => {
+testAll('test tasks', async ({ createEntity }) => {
     let c = await createEntity(tasks);
     let t = c.create();
     t.id = 1;
@@ -223,9 +233,9 @@ testAll("test filtering of null/''", async ({ createEntity }) => {
     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);
+    expect(await repo.count({ refH: { '!=': null } })).toBe(1);
 }, false);
-testAll("test paging with complex object", async ({ remult, createEntity }) => {
+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();
@@ -238,13 +248,13 @@ testAll("test paging with complex object", async ({ remult, createEntity }) => {
     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" }
+        orderBy: { c: 'asc', id: 'asc' },
     })) {
         i++;
     }
     expect(i).toBe(5);
 }, false);
-testAll("test paging with complex object_2", async ({ remult, createEntity }) => {
+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);
@@ -275,16 +285,16 @@ testAll("test filter doesn't collapse", async ({ createEntity }) => {
     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 }) => {
+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);
+    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 }) => {
+testAll('put with validations on column fails', async ({ remult, createEntity }) => {
     var s = await createEntity(entityWithValidationsOnColumn);
     let c = s.create();
     c.myId = 1;
@@ -298,13 +308,13 @@ testAll("put with validations on column fails", async ({ remult, createEntity })
         d.ok();
     };
     await api.put(t, 1, {
-        name: '1'
+        name: '1',
     });
     d.test();
     var x = await s.find({ where: { myId: 1 } });
     expect(x[0].name).toBe('noam');
 });
-testAllDbs("Insert", async ({ createData }) => {
+testAllDbs('Insert', async ({ createData }) => {
     let forCat = await createData(async (x) => { });
     let rows = await forCat.find();
     expect(rows.length).toBe(0);
@@ -317,7 +327,7 @@ testAllDbs("Insert", async ({ createData }) => {
     expect(rows[0].id).toBe(1);
     expect(rows[0].categoryName).toBe('noam');
 }, false);
-testAllDbs("test delete", async ({ createData }) => {
+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);
@@ -326,24 +336,33 @@ testAllDbs("test delete", async ({ createData }) => {
     rows = await c.find();
     expect(rows.length).toBe(0);
 }, false);
-testAllDbs("test filter packer", async ({ insertFourRows }) => {
+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' }))
+        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 })) });
+    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' })) });
+    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] } })) });
+    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 }) => {
+testAll('Test unique Validation,', async ({ createEntity }) => {
     let type = class extends newCategories {
     };
     Entity('categories')(type);
@@ -353,8 +372,8 @@ testAll("Test unique Validation,", async ({ createEntity }) => {
                 if (await c.count({ a: en.a }))
                     en._.fields.a.error = 'already exists';
             }
-        }
-    })(type.prototype, "a");
+        },
+    })(type.prototype, 'a');
     var c = await createEntity(type);
     var cat = c.create();
     cat.a = '12';
@@ -368,17 +387,17 @@ testAll("Test unique Validation,", async ({ createEntity }) => {
         saved = true;
     }
     catch (err) {
-        expect(cat._.fields.a.error).toEqual("already exists");
+        expect(cat._.fields.a.error).toEqual('already exists');
     }
     expect(saved).toBe(false);
 });
-testAll("Test unique Validation 2", async ({ createEntity }) => {
+testAll('Test unique Validation 2', async ({ createEntity }) => {
     let type = class extends newCategories {
     };
     Entity('sdfgds')(type);
     Fields.string({
-        validate: Validators.unique
-    })(type.prototype, "a");
+        validate: Validators.unique,
+    })(type.prototype, 'a');
     var c = await createEntity(type);
     var cat = c.create();
     cat.a = '12';
@@ -391,7 +410,7 @@ testAll("Test unique Validation 2", async ({ createEntity }) => {
         saved = true;
     }
     catch (err) {
-        expect(cat._.fields.a.error).toEqual("already exists");
+        expect(cat._.fields.a.error).toEqual('already exists');
     }
     expect(saved).toBe(false);
 });
@@ -408,15 +427,17 @@ __decorate([
 testNumbers = __decorate([
     Entity('testNumbers', { allowApiCrud: true })
 ], testNumbers);
-testAll("test that integer and int work", async ({ createEntity }) => {
-    let e = await (await createEntity(testNumbers)).create({
+testAll('test that integer and int work', async ({ createEntity }) => {
+    let e = await (await createEntity(testNumbers))
+        .create({
         id: 1.5,
-        a: 1.5
-    }).save();
+        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 }) => {
+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();
@@ -431,7 +452,7 @@ testAll("post with logic works and max in entity", async ({ remult, createEntity
     expect(entityWithValidations.savingRowCount).toBe(1);
     d.test();
 });
-testAllDbs("get array works with filter in body", async ({ createData, remult }) => {
+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);
@@ -440,31 +461,31 @@ testAllDbs("get array works with filter in body", async ({ createData, remult })
     var api = new DataApi(c, remult);
     let t = new TestDataApiResponse();
     let d = new Done();
-    t.success = data => {
+    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 => {
+        get: (x) => {
             return undefined;
-        }
+        },
     }, {
-        "status.in": '[1, 2]'
+        'status.in': '[1, 2]',
     });
     d.test();
 }, false);
-testAllDbs("entity order by works", async ({ createData }) => {
+testAllDbs('entity order by works', async ({ createData }) => {
     let type = class extends newCategories {
     };
     Entity('', {
-        defaultOrderBy: { categoryName: "asc" },
+        defaultOrderBy: { categoryName: 'asc' },
     })(type);
     let c = await createData(async (insert) => {
         await insert(1, 'noam');
-        await insert(2, "yoni");
-        await insert(3, "yael");
+        await insert(2, 'yoni');
+        await insert(3, 'yael');
     }, type);
     var x = await c.find();
     expect(x[0].id).toBe(1);
@@ -479,7 +500,7 @@ testAllDbs("entity order by works", async ({ createData }) => {
     expect(x[1].id).toBe(3);
     expect(x[2].id).toBe(2);
 }, false);
-testAllDbs("put with validation works", async ({ createData, remult }) => {
+testAllDbs('put with validation works', async ({ createData, remult }) => {
     let count = 0;
     let type = class extends newCategories {
     };
@@ -488,7 +509,7 @@ testAllDbs("put with validation works", async ({ createData, remult }) => {
         saving: () => {
             if (!testConfiguration.restDbRunningOnServer)
                 count++;
-        }
+        },
     })(type);
     let c = await createData(async (insert) => await insert(1, 'noam'), type);
     var api = new DataApi(c, remult);
@@ -499,16 +520,16 @@ testAllDbs("put with validation works", async ({ createData, remult }) => {
     };
     count = 0;
     await api.put(t, 1, {
-        categoryName: 'noam 1'
+        categoryName: 'noam 1',
     });
     d.test();
     var x = await c.find({
-        where: { id: 1 }
+        where: { id: 1 },
     });
     expect(x[0].categoryName).toBe('noam 1');
     expect(count).toBe(1);
 });
-testAll("saves correctly to db", async ({ createEntity }) => {
+testAll('saves correctly to db', async ({ createEntity }) => {
     let type = class extends EntityBase {
         constructor() {
             super(...arguments);
@@ -517,7 +538,7 @@ testAll("saves correctly to db", async ({ createEntity }) => {
     };
     Entity('asdf', { allowApiCrud: true })(type);
     Fields.number()(type.prototype, 'id');
-    Fields.boolean()(type.prototype, "ok");
+    Fields.boolean()(type.prototype, 'ok');
     let r = (await createEntity(type)).create();
     r.id = 1;
     r.ok = true;
@@ -538,7 +559,7 @@ __decorate([
     __metadata("design:type", Number)
 ], autoIncrement.prototype, "stam", void 0);
 autoIncrement = __decorate([
-    Entity("autoi", { allowApiCrud: true })
+    Entity('autoi', { allowApiCrud: true })
 ], autoIncrement);
 testAll("auto increment can't be affected by insert or update", async ({ createEntity }) => {
     let repo = await createEntity(autoIncrement);
@@ -549,24 +570,58 @@ testAll("auto increment can't be affected by insert or update", async ({ createE
     await r.save();
     expect(r.id).toBe(x);
 }, false);
-testAll("Paging", async ({ createEntity }) => {
+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);
+    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 }) => {
+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('')]
+        $and: [testFilter.search('')],
     })).toBe(0);
 }, false);
-testAll("large string field", async ({ createEntity }) => {
+testAll('filter 2_1', async ({ createEntity }) => {
+    const s = await createEntity(testFilter);
+    await s.insert({ id: 1, a: 'a', b: 'b', c: 'c' });
+    expect(await s.count({
+        $and: [{ a: { '!=': 'b' } }, { a: { '!=': 'c' } }],
+    })).toBe(1);
+}, false);
+testAll('filter 2', async ({ createEntity }) => {
+    const s = await createEntity(testFilter);
+    await s.insert({ id: 1, a: 'a', b: 'b', c: 'c' });
+    expect(await s.count({
+        $and: [testFilter.differentFrom('b'), testFilter.differentFrom('c')],
+    })).toBe(1);
+}, false);
+testAll('filter 3', async ({ createEntity }) => {
+    const s = await createEntity(testFilter);
+    await s.insert({ id: 1, a: 'a', b: 'b', c: 'c' });
+    expect(await s.count({
+        $and: [
+            testFilter.differentFromArray(['x', 'b']),
+            testFilter.differentFromArray(['y', 'c']),
+        ],
+    })).toBe(1);
+}, false);
+testAll('filter 4', async ({ createEntity }) => {
+    const s = await createEntity(testFilter);
+    await s.insert({ id: 1, a: 'a', b: 'b', c: 'c' });
+    expect(await s.count({
+        $and: [
+            testFilter.differentFromObj({ str: 'b' }),
+            testFilter.differentFromObj({ str: 'c' }),
+        ],
+    })).toBe(1);
+}, false);
+testAll('large string field', async ({ createEntity }) => {
     const s = await createEntity(stam);
-    await s.insert({ title: "1234567890".repeat(100) });
+    await s.insert({ title: '1234567890'.repeat(100) });
     const r = await s.findFirst();
-    expect(r.title).toBe("1234567890".repeat(100));
+    expect(r.title).toBe('1234567890'.repeat(100));
 }, false);
 let testFilter = class testFilter {
     constructor() {
@@ -577,14 +632,27 @@ let testFilter = class testFilter {
     }
 };
 testFilter.search = Filter.createCustom((str, remult) => ({
-    $and: [{
-            $or: [
-                { a: 'a' },
-                { b: 'a' },
-                { c: 'a' }
-            ]
-        }]
+    $and: [
+        {
+            $or: [{ a: 'a' }, { b: 'a' }, { c: 'a' }],
+        },
+    ],
 }));
+testFilter.differentFrom = Filter.createCustom((str) => {
+    return {
+        a: { '!=': str },
+    };
+});
+testFilter.differentFromObj = Filter.createCustom(({ str }) => {
+    return {
+        a: { '!=': str },
+    };
+});
+testFilter.differentFromArray = Filter.createCustom((str) => {
+    return {
+        a: { '!=': str },
+    };
+});
 __decorate([
     Fields.integer(),
     __metadata("design:type", Number)
@@ -602,7 +670,7 @@ __decorate([
     __metadata("design:type", String)
 ], testFilter.prototype, "c", void 0);
 testFilter = __decorate([
-    Entity("testfilter", { allowApiCrud: true })
+    Entity('testfilter', { allowApiCrud: true })
 ], testFilter);
 let testStringWithNull = class testStringWithNull extends EntityBase {
     constructor() {
@@ -637,7 +705,7 @@ __decorate([
     __metadata("design:type", String)
 ], stam.prototype, "title", void 0);
 stam = __decorate([
-    Entity("a", { allowApiCrud: true })
+    Entity('a', { allowApiCrud: true })
 ], stam);
 export { stam };
 let p = class p extends EntityBase {
@@ -684,7 +752,7 @@ __decorate([
 ], tasksWithEnum.prototype, "priority", void 0);
 tasksWithEnum = __decorate([
     Entity('tasksWithEnum', {
-        allowApiCrud: true
+        allowApiCrud: true,
     })
 ], tasksWithEnum);
 export { tasksWithEnum };
@@ -694,11 +762,11 @@ export var Priority;
     Priority[Priority["High"] = 1] = "High";
     Priority[Priority["Critical"] = 2] = "Critical";
 })(Priority || (Priority = {}));
-testAll("task with enum", async ({ createEntity }) => {
+testAll('task with enum', async ({ createEntity }) => {
     const r = await createEntity(tasksWithEnum);
     await r.insert({
         title: 'a',
-        priority: Priority.Critical
+        priority: Priority.Critical,
     });
     const item = await r.findFirst();
     expect(item.priority).toBe(Priority.Critical);
@@ -727,7 +795,7 @@ __decorate([
 ], tasksWithStringEnum.prototype, "priority", void 0);
 tasksWithStringEnum = __decorate([
     Entity('tasksWithStringEnum', {
-        allowApiCrud: true
+        allowApiCrud: true,
     })
 ], tasksWithStringEnum);
 export { tasksWithStringEnum };
@@ -737,88 +805,87 @@ export var PriorityWithString;
     PriorityWithString["High"] = "High";
     PriorityWithString["Critical"] = "Critical";
 })(PriorityWithString || (PriorityWithString = {}));
-testAll("task with enum string", async ({ createEntity }) => {
+testAll('task with enum string', async ({ createEntity }) => {
     const r = await createEntity(tasksWithStringEnum);
     await r.insert({
         title: 'a',
-        priority: PriorityWithString.Critical
+        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 }) => {
+testAll('test transaction rollback', async ({ db, createEntity }) => {
     let fail = true;
     const r = await createEntity(stam);
-    await r.insert({ title: "task b", id: 1 });
+    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 });
+            await remultWithTransaction.insert({ title: 'task a', id: 2 });
             expect(await remultWithTransaction.count()).toBe(2);
-            throw "error";
+            throw 'error';
         });
         fail = false;
     }
-    catch {
-    }
+    catch { }
     expect(await r.count()).toBe(1);
     expect(fail).toBe(true);
 }, false, { exclude: [TestDbs.inMemory] });
-testAll("test date", async ({ createEntity }) => {
+testAll('test date', async ({ createEntity }) => {
     const e = class {
         constructor() {
             this.a = 0;
             this.d = new Date();
         }
     };
-    describeClass(e, Entity("tdate", { allowApiCrud: true }), {
+    describeClass(e, Entity('tdate', { allowApiCrud: true }), {
         a: Fields.number(),
-        d: Fields.date()
+        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 }) => {
+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");
+    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([]);
+    expect(await x.keepAliveAndReturnUnknownQueryIds([id])).toEqual([]);
 }, false, {
-    exclude: [TestDbs.restDataProvider]
+    exclude: [TestDbs.restDataProvider],
 });
-testAll("test contains with names with casing", async ({ createEntity }) => {
+testAll('test contains with names with casing', async ({ createEntity }) => {
     const e = class {
         constructor() {
             this.a = 0;
             this.firstName = '';
         }
     };
-    describeClass(e, Entity("testNameContains", { allowApiCrud: true }), {
+    describeClass(e, Entity('testNameContains', { allowApiCrud: true }), {
         a: Fields.number(),
-        firstName: Fields.string()
+        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");
+    await r.insert({ a: 1, firstName: 'noam' });
+    let item = await r.findFirst({ firstName: { $contains: 'oa' } });
+    expect(item.firstName).toBe('noam');
 }, false, {
-    exclude: [TestDbs.mongo]
+    exclude: [TestDbs.mongo],
 });
-testAll("test live query storage", async (x) => {
+testAll('test live query storage', async (x) => {
     await x.createEntity(LiveQueryStorageEntity);
     const s = new DataProviderLiveQueryStorage(x.db);
     await s.ensureSchema();
-    const entityKey = "ek";
+    const entityKey = 'ek';
     const id = 'id';
     await s.add({ id, entityKey, data: {} });
     await s.add({ id, entityKey, data: {} });
@@ -828,25 +895,25 @@ testAll("test live query storage", async (x) => {
     await s.remove(id);
     await s.remove(id);
 }, false, { exclude: [TestDbs.restDataProvider] });
-testAll("test json structure using object", async ({ createEntity }) => {
+testAll('test json structure using object', async ({ createEntity }) => {
     const e = class {
         constructor() {
             this.a = 0;
         }
     };
-    describeClass(e, Entity("testJsonStructure", { allowApiCrud: true }), {
+    describeClass(e, Entity('testJsonStructure', { allowApiCrud: true }), {
         a: Fields.number(),
-        person: Fields.object()
+        person: Fields.object(),
     });
     const r = await createEntity(e);
-    await r.insert({ a: 1, person: { firstName: "noam", lastName: "honig" } });
+    await r.insert({ a: 1, person: { firstName: 'noam', lastName: 'honig' } });
     let item = await r.findFirst();
-    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+    expect(item.person).toEqual({ firstName: 'noam', lastName: 'honig' });
 }, false);
 let testObject = class testObject {
     constructor() {
         this.id = 0;
-        this.person = { firstName: "noam", lastName: "honig" };
+        this.person = { firstName: 'noam', lastName: 'honig' };
     }
 };
 __decorate([
@@ -858,18 +925,18 @@ __decorate([
     __metadata("design:type", Object)
 ], testObject.prototype, "person", void 0);
 testObject = __decorate([
-    Entity("testObject", { allowApiCrud: true })
+    Entity('testObject', { allowApiCrud: true })
 ], testObject);
-testAll("test object entity", async ({ createEntity }) => {
+testAll('test object entity', async ({ createEntity }) => {
     const r = await createEntity(testObject);
-    await r.insert({ id: 1, person: { firstName: "noam", lastName: "honig" } });
+    await r.insert({ id: 1, person: { firstName: 'noam', lastName: 'honig' } });
     let item = await r.findFirst();
-    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+    expect(item.person).toEqual({ firstName: 'noam', lastName: 'honig' });
 }, false);
 let testObjectJson = class testObjectJson {
     constructor() {
         this.id = 0;
-        this.person = { firstName: "noam", lastName: "honig" };
+        this.person = { firstName: 'noam', lastName: 'honig' };
     }
 };
 __decorate([
@@ -881,62 +948,97 @@ __decorate([
     __metadata("design:type", Object)
 ], testObjectJson.prototype, "person", void 0);
 testObjectJson = __decorate([
-    Entity("testObjectJson", { allowApiCrud: true })
+    Entity('testObjectJson', { allowApiCrud: true })
 ], testObjectJson);
-testAll("test object entity", async ({ createEntity }) => {
+testAll('test object entity', async ({ createEntity }) => {
     const r = await createEntity(testObjectJson);
-    await r.insert({ id: 1, person: { firstName: "noam", lastName: "honig" } });
+    await r.insert({ id: 1, person: { firstName: 'noam', lastName: 'honig' } });
     let item = await r.findFirst();
-    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+    expect(item.person).toEqual({ firstName: 'noam', lastName: 'honig' });
 }, false);
-testAll("test json structure", async ({ createEntity }) => {
+testAll('test json structure', async ({ createEntity }) => {
     const e = class {
         constructor() {
             this.a = 0;
         }
     };
-    describeClass(e, Entity("testJsonFieldType", { allowApiCrud: true }), {
+    describeClass(e, Entity('testJsonFieldType', { allowApiCrud: true }), {
         a: Fields.number(),
-        person: Fields.json()
+        person: Fields.json(),
     });
     const r = await createEntity(e);
-    await r.insert({ a: 1, person: { firstName: "noam", lastName: "honig" } });
+    await r.insert({ a: 1, person: { firstName: 'noam', lastName: 'honig' } });
     let item = await r.findFirst();
-    expect(item.person).toEqual({ firstName: "noam", lastName: "honig" });
+    expect(item.person).toEqual({ firstName: 'noam', lastName: 'honig' });
 }, false);
-testAll("test json structure 2", async ({ createEntity }) => {
+testAll('test json structure 2', async ({ createEntity }) => {
     const e = class {
         constructor() {
             this.a = 0;
             this.items = [];
         }
     };
-    describeClass(e, Entity("testJsonFieldType2", { allowApiCrud: true }), {
+    describeClass(e, Entity('testJsonFieldType2', { allowApiCrud: true }), {
         a: Fields.number(),
-        items: Fields.json()
+        items: Fields.json(),
     });
     const r = await createEntity(e);
-    await r.insert({ a: 1, items: ["a", "b"] });
+    await r.insert({ a: 1, items: ['a', 'b'] });
     let item = await r.findFirst();
-    expect(item.items).toEqual(["a", "b"]);
+    expect(item.items).toEqual(['a', 'b']);
     //expect(await r.count({ items: { $contains: "b" } })).toBe(1)
-}, false, { exclude: [TestDbs.mongo] });
-testAll("test json structure 3", async ({ createEntity }) => {
+}, false);
+testAll('test json structure 3', async ({ createEntity }) => {
     const e = class {
         constructor() {
             this.a = 0;
             this.items = [];
         }
     };
-    describeClass(e, Entity("testJsonFieldType3", { allowApiCrud: true }), {
+    describeClass(e, Entity('testJsonFieldType3', { allowApiCrud: true }), {
         a: Fields.number(),
-        items: Fields.object()
+        items: Fields.object(),
     });
     const r = await createEntity(e);
-    await r.insert({ a: 1, items: ["a", "b"] });
+    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);
+    expect(item.items).toEqual(['a', 'b']);
+    expect(await r.count({ items: { $contains: 'b' } })).toBe(1);
 }, false, {
-    exclude: [TestDbs.mongo]
+    exclude: [TestDbs.mongo],
 });
+testAll('test relation to number id', async ({ createEntity }) => {
+    const category = class {
+        constructor() {
+            this.id = 0;
+            this.name = '';
+        }
+    };
+    describeClass(category, Entity('rel_ID_categories', { allowApiCrud: true }), {
+        id: Fields.autoIncrement(),
+        name: Fields.string(),
+    });
+    const task = class {
+        constructor() {
+            this.id = 0;
+            this.title = '';
+        }
+    };
+    describeClass(task, Entity('rel_ID_task', { allowApiCrud: true }), {
+        id: Fields.autoIncrement(),
+        title: Fields.string(),
+        category: Field(() => category),
+    });
+    const catRepo = await createEntity(category);
+    const taskRepo = await createEntity(task);
+    const cat = await catRepo.insert([{ name: 'cat0' }, { name: 'cat1' }]);
+    await taskRepo.insert([
+        { title: 't1', category: cat[0] },
+        { title: 't2', category: cat[0] },
+        { title: 't3', category: cat[1] },
+    ]);
+    expect(taskRepo.fields.category.valueConverter.fieldTypeInDb).toBe(ValueConverters.Integer.fieldTypeInDb);
+    expect(await taskRepo.count({ category: cat[0] })).toBe(2);
+    expect(await taskRepo.count({ category: cat[1] })).toBe(1);
+    expect(await taskRepo.count({ category: { $id: cat[0].id } })).toBe(2);
+}, false, { exclude: [TestDbs.mongo] });