remult 0.21.1 → 0.22.0

package/esm/core/src/tests/test-server-method-on-entity.spec.js

@@ -0,0 +1,306 @@
+import { ActionTestConfig, testRestDb } from './testHelper.spec';
+import { TestDataApiResponse } from "./TestDataApiResponse";
+import { Remult, isBackend } from '../context';
+import { actionInfo, BackendMethod } from '../server-action';
+import { Field, Entity, EntityBase, getEntityRef, Fields } from '../remult3';
+import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { DataApi } from '../data-api';
+import { assign } from '../../assign';
+import { dWithPrefilter } from './dWithPrefilter';
+import { describeClass } from '../remult3/DecoratorReplacer';
+@Entity('testServerMethodOnEntity')
+class testServerMethodOnEntity extends EntityBase {
+    remult;
+    constructor(remult) {
+        super();
+        this.remult = remult;
+    }
+    @Fields.string({
+        validate: (y, x) => {
+            if (y.a == "errorc") {
+                x.error = "error on client";
+            }
+            else if (y.a == "error on server" && isBackend()) {
+                x.error = "error on server";
+            }
+        }
+    })
+    a;
+    @BackendMethod({ allowed: true })
+    async doIt1() {
+        let result = 'hello ' + this.a;
+        this.a = 'yael';
+        return {
+            onServer: isBackend(),
+            result
+        };
+    }
+    async doIt1NoDecorator() {
+        let result = 'hello ' + this.a;
+        this.a = 'yael';
+        return {
+            onServer: isBackend(),
+            result
+        };
+    }
+    @BackendMethod({ allowed: true })
+    async doItAgain() {
+        expect(await this.remult.repo(testServerMethodOnEntity).count()).toBe(0);
+        await this._.save();
+        expect(await this.remult.repo(testServerMethodOnEntity).count()).toBe(1);
+        return (await this.remult.repo(testServerMethodOnEntity).findFirst()).a;
+    }
+}
+describeClass(testServerMethodOnEntity, undefined, {
+    doIt1NoDecorator: BackendMethod({ allowed: true, paramTypes: [Remult] })
+});
+@Entity('testBoolCreate123', (o, c) => assign(o, {
+    allowApiCrud: true,
+    saving: async (t) => {
+        if (isBackend() && t._.isNew()) {
+            await c.repo(testBoolCreate123).count();
+            await new Promise((res, rej) => setTimeout(() => {
+                res({});
+            }, 20));
+            t.ok123 = true;
+        }
+    }
+}))
+class testBoolCreate123 extends EntityBase {
+    @Fields.number()
+    id;
+    @Fields.boolean({})
+    ok123 = false;
+    @BackendMethod({ allowed: true })
+    async testIt() {
+        await this._.save();
+    }
+}
+describe("test Server method in entity", () => {
+    let c = new Remult();
+    it("test server method on Entity", async () => {
+        let x = c.repo(testServerMethodOnEntity).create();
+        x.a = 'Noam';
+        let r = await x.doIt1();
+        expect(r.onServer).toBe(true);
+        expect(r.result).toBe('hello Noam');
+        expect(x.a).toBe("yael");
+    });
+    it("test server method on Entity without decorator", async () => {
+        let x = c.repo(testServerMethodOnEntity).create();
+        x.a = 'Noam';
+        let r = await x.doIt1NoDecorator();
+        expect(r.onServer).toBe(true);
+        expect(r.result).toBe('hello Noam');
+        expect(x.a).toBe("yael");
+    });
+    it("test server method on Entity", async () => {
+        let x = c.repo(testServerMethodOnEntity).create();
+        x.a = 'Noam';
+        expect(await x.doItAgain()).toBe("Noam");
+    });
+    it("test validation method", async () => {
+        let x = c.repo(testServerMethodOnEntity).create();
+        x.a = 'errorc';
+        let happened = false;
+        try {
+            let r = await x.doIt1();
+            happened = true;
+        }
+        catch (err) {
+            expect(err.modelState.a).toBe("error on client");
+            expect(getEntityRef(x).fields.a.error).toBe("error on client");
+        }
+        expect(happened).toBe(false);
+    });
+    it("test backend method with adhoc entity", async () => {
+        const myClass = class {
+            id = 0;
+            name = '';
+            async doSomething() {
+                return this.name + isBackend();
+            }
+        };
+        describeClass(myClass, Entity('adHocEntity'), {
+            id: Fields.autoIncrement(),
+            name: Fields.string(),
+            doSomething: BackendMethod({ allowed: true }),
+        });
+        const x = new Remult().repo(myClass).create();
+        x.name = "123";
+        expect(await x.doSomething()).toBe("123true");
+    });
+    it("test static backend method with adhoc entity", async () => {
+        const myClass = class {
+            id = 0;
+            name = '';
+            static async adHockDoSomething() {
+                return isBackend();
+            }
+        };
+        describeClass(myClass, Entity('adHocEntity'), {
+            id: Fields.autoIncrement(),
+            name: Fields.string()
+        }, {
+            adHockDoSomething: BackendMethod({ allowed: true }),
+        });
+        expect(await myClass.adHockDoSomething()).toBe(true);
+    });
+    it("test validation on server", async () => {
+        let x = c.repo(testServerMethodOnEntity).create();
+        x.a = "error on server";
+        let happened = false;
+        try {
+            let r = await x.doIt1();
+            happened = true;
+        }
+        catch (err) {
+            expect(err.modelState.a).toBe("error on server");
+            expect(getEntityRef(x).fields.a.error).toBe("error on server");
+        }
+        expect(happened).toBe(false);
+    });
+    it("saves correctly to db", async () => {
+        actionInfo.runningOnServer = true;
+        let remult = new Remult();
+        remult.dataProvider = (new InMemoryDataProvider());
+        let r = remult.repo(testBoolCreate123);
+        let dataApi = new DataApi(r, remult);
+        let t = new TestDataApiResponse();
+        t.created = x => {
+            expect(x.ok123).toBe(true);
+        };
+        await dataApi.post(t, { id: 1, ok123: false });
+        t.success = x => {
+            expect(x.ok123).toBe(false);
+        };
+        await dataApi.put(t, 1, { ok123: false });
+        actionInfo.runningOnServer = false;
+    });
+});
+@Entity('a')
+class a extends EntityBase {
+    @Fields.integer()
+    id;
+}
+@Entity('b')
+class b extends EntityBase {
+    @Fields.integer()
+    id;
+    @Field(() => a)
+    a;
+}
+@Entity('c')
+class c extends EntityBase {
+    remult;
+    @Fields.integer()
+    id;
+    @Field(() => b)
+    b;
+    @BackendMethod({ allowed: true })
+    async doIt() {
+        expect(this.b.id).toBe(11);
+        expect(this.b.a.id).toBe(1);
+        this.b = await this.remult.repo(b).findId(12);
+        expect(this.b.id).toBe(12);
+        expect(this.b.a.id).toBe(2);
+        await this.save();
+        return this.b.a.id;
+    }
+    @BackendMethod({ allowed: true })
+    async doIt2() {
+        expect(this.b.id).toBe(12);
+        expect(this.b.a.id).toBe(2);
+        await this.save();
+        return this.b.a.id;
+    }
+    constructor(remult) {
+        super();
+        this.remult = remult;
+    }
+}
+describe("complex entity relations on server entity and backend method", () => {
+    beforeEach(() => {
+        ActionTestConfig.db.rows = [];
+    });
+    it("fix it", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (ActionTestConfig.db);
+        let a1 = await remult.repo(a).create({ id: 1 }).save();
+        let a2 = await remult.repo(a).create({ id: 2 }).save();
+        let b1 = await remult.repo(b).create({ id: 11, a: a1 }).save();
+        let b2 = await remult.repo(b).create({ id: 12, a: a2 }).save();
+        let c1 = await remult.repo(c).create({ id: 21, b: b1 }).save();
+        remult = new Remult(); //clear the cache;
+        remult.dataProvider = (ActionTestConfig.db);
+        let r = await c1.doIt();
+        expect(r).toBe(2);
+        expect(c1.b.id).toBe(12);
+        expect(c1.b.a.id).toBe(2);
+    });
+    it("fix it new row", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (ActionTestConfig.db);
+        let a1 = await remult.repo(a).create({ id: 1 }).save();
+        let a2 = await remult.repo(a).create({ id: 2 }).save();
+        let b1 = await remult.repo(b).create({ id: 11, a: a1 }).save();
+        let b2 = await remult.repo(b).create({ id: 12, a: a2 }).save();
+        remult = new Remult(); //clear the cache;
+        remult.dataProvider = (ActionTestConfig.db);
+        let c1 = await remult.repo(c).create({ id: 21, b: b1 });
+        let r = await c1.doIt();
+        expect(r).toBe(2);
+        expect(c1.b.id).toBe(12);
+        expect(c1.b.a.id).toBe(2);
+    });
+    it("fix it change value", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (ActionTestConfig.db);
+        let a1 = await remult.repo(a).create({ id: 1 }).save();
+        let a2 = await remult.repo(a).create({ id: 2 }).save();
+        let b1 = await remult.repo(b).create({ id: 11, a: a1 }).save();
+        let b2 = await remult.repo(b).create({ id: 12, a: a2 }).save();
+        let c1 = await remult.repo(c).create({ id: 21, b: b1 }).save();
+        remult = new Remult(); //clear the cache;
+        remult.dataProvider = (ActionTestConfig.db);
+        c1 = await remult.repo(c).findId(21);
+        c1.b = b2;
+        let r = await c1.doIt2();
+        expect(r).toBe(2);
+        expect(c1.b.id).toBe(12);
+        expect(c1.b.a.id).toBe(2);
+    });
+});
+it("test that entity backend method respects api filter", async () => {
+    let remult = new Remult(ActionTestConfig.db);
+    let repo = remult.repo(dWithPrefilter);
+    await repo.query().forEach(x => x.delete());
+    let d1 = await repo.create({ id: 1, b: 1 }).save();
+    await repo.create({ id: 2, b: 1 }).save();
+    await repo.create({ id: 3, b: 2 }).save();
+    let d4 = await repo.create({ id: 4, b: 2 }).save();
+    dWithPrefilter.count = 0;
+    expect(await d4.doIt()).toBe(true);
+    ;
+    expect(dWithPrefilter.count).toBe(1);
+    dWithPrefilter.count = 0;
+    let error = false;
+    try {
+        await d1.doIt();
+    }
+    catch {
+        error = true;
+    }
+    expect(error).toBe(true);
+    expect(dWithPrefilter.count).toBe(0);
+});
+it("test api filter cant be overwritten", async () => {
+    return testRestDb(async ({ remult }) => {
+        let repo = remult.repo(dWithPrefilter);
+        let d1 = await repo.create({ id: 1, b: 1 }).save();
+        await repo.create({ id: 3, b: 2 }).save();
+        let d4 = await repo.create({ id: 4, b: 2 }).save();
+        expect(await repo.count({ b: 1 })).toBe(0);
+        expect((await repo.find({ where: { b: 1 } })).length).toBe(0);
+    });
+});

package/esm/core/src/tests/test-sql-expression.spec.d.ts

@@ -0,0 +1,5 @@
+import { SqlCommand, SqlResult } from '../sql-command';
+export declare class myDummySQLCommand implements SqlCommand {
+    execute(sql: string): Promise<SqlResult>;
+    addParameterAndReturnSqlToken(val: any): string;
+}

package/esm/core/src/tests/test-sql-expression.spec.js

@@ -0,0 +1,205 @@
+import { Remult } from '../context';
+import { SqlDatabase } from '../data-providers/sql-database';
+import { WebSqlDataProvider } from '../data-providers/web-sql-data-provider';
+import { Field, Entity, EntityBase, ValueListFieldType, Fields, getValueList, ValueListInfo, IdEntity } from '../remult3';
+import { postgresColumnSyntax } from '../../postgres/schema-builder';
+import { FilterConsumerBridgeToSqlRequest, dbNamesOf, isDbReadonly } from '../filter/filter-consumer-bridge-to-sql-request';
+describe("test sql database expressions", () => {
+    let web = new WebSqlDataProvider("test");
+    let db = new SqlDatabase(web);
+    let remult = new Remult();
+    remult.dataProvider = (db);
+    async function deleteAll() {
+        await web.dropTable(remult.repo(testSqlExpression).metadata);
+        await web.dropTable(remult.repo(expressionEntity).metadata);
+    }
+    it("test basics", async () => {
+        await deleteAll();
+        let x = remult.repo(testSqlExpression).create();
+        x.code = 3;
+        await x._.save();
+        expect(x.code).toBe(3);
+        expect(x.testExpression).toBe(15, "after save");
+        expect(x._.fields.testExpression.originalValue).toBe(15, "after save");
+        x = await remult.repo(testSqlExpression).findFirst();
+        expect(x.testExpression).toBe(15);
+    });
+    it("test undefined behaves as a column", async () => {
+        await deleteAll();
+        let x = remult.repo(expressionEntity);
+        let n = await dbNamesOf(x.metadata);
+        expect((n.col)).toBe('col');
+        expect((await x.create({ col: 'abc', id: 1 }).save()).col).toBe('abc');
+        expect(isDbReadonly(x.metadata.fields.col, n)).toBe(false);
+        let c = new Remult();
+        c.dataProvider = (db);
+        expressionEntity.yes = true;
+        x = c.repo(expressionEntity);
+        n = await dbNamesOf(x.metadata);
+        expect(n.col).toBe("'1+1'");
+        expect((await x.create({ col: 'abc', id: 2 }).save()).col).toBe('1+1');
+        expect(isDbReadonly(x.metadata.fields.col, n)).toBe(true);
+    });
+    it("test asyync dbname", async () => {
+        let z = await remult.repo(testServerExpression1).metadata.getDbName();
+        expect(z).toBe('testServerExpression1');
+    });
+});
+@Entity('expressionEntity')
+class expressionEntity extends EntityBase {
+    @Fields.integer()
+    id;
+    static yes;
+    @Fields.string({
+        sqlExpression: async () => expressionEntity.yes ? "'1+1'" : undefined
+    })
+    col;
+}
+@Entity('testSqlExpression')
+class testSqlExpression extends EntityBase {
+    @Fields.number()
+    code;
+    @Fields.number({
+        sqlExpression: async (x) => {
+            return await x.fields.code.getDbName() + ' * 5';
+        }
+    })
+    testExpression;
+}
+@Entity('testServerExpression1', {
+    sqlExpression: async () => new Promise(res => setTimeout(() => {
+        res('testServerExpression1');
+    }, 30))
+})
+class testServerExpression1 extends EntityBase {
+    @Fields.number()
+    code;
+}
+export class myDummySQLCommand {
+    execute(sql) {
+        throw new Error("Method not implemented.");
+    }
+    addParameterAndReturnSqlToken(val) {
+        if (val === null)
+            return "null";
+        if (val instanceof Date)
+            val = val.toISOString();
+        if (typeof (val) == "string") {
+            return '\'' + val.replace(/'/g, '\'\'') + '\'';
+        }
+        return val.toString();
+    }
+}
+describe("test filter for date", () => {
+    it("filter", async () => {
+        let c = new Remult();
+        let e = c.repo(testCreate);
+        var d = new myDummySQLCommand();
+        var db = await dbNamesOf(e.metadata);
+        let f = new FilterConsumerBridgeToSqlRequest(d, db);
+        f.isGreaterOrEqualTo(e.metadata.fields.theDate, new Date("2021-08-06T05:05:25.440Z"));
+        expect(await f.resolveWhere()).toBe(" where theDate >= '" + new Date(2021, 7, 6).toISOString() + "'");
+    });
+});
+describe("Postgres create db", () => {
+    let c = new Remult();
+    it("what", () => {
+        let e = c.repo(testCreate);
+        expect(postgresColumnSyntax(e.metadata.fields.theDate, "x")).toBe("x date");
+        expect(postgresColumnSyntax(e.metadata.fields.i, "x")).toBe("x integer default 0 not null");
+        expect(postgresColumnSyntax(e.metadata.fields.s, "x")).toBe("x varchar default '' not null", "s");
+        expect(postgresColumnSyntax(e.metadata.fields.s2, "x")).toBe("x varchar default '' not null", "s2");
+    });
+});
+@ValueListFieldType()
+class intId {
+    id;
+    caption;
+    static z = new intId(0, '');
+    constructor(id, caption) {
+        this.id = id;
+        this.caption = caption;
+    }
+}
+@ValueListFieldType()
+class stringId {
+    id;
+    caption;
+    static z = new stringId('0', '');
+    constructor(id, caption) {
+        this.id = id;
+        this.caption = caption;
+    }
+}
+@ValueListFieldType()
+class stringId2 {
+    id;
+    caption;
+    static z = new stringId2();
+    constructor(id, caption) {
+        this.id = id;
+        this.caption = caption;
+    }
+}
+@Entity('testCreate')
+class testCreate extends IdEntity {
+    @Fields.dateOnly()
+    theDate;
+    @Field(() => intId)
+    i;
+    @Field(() => stringId)
+    s;
+    @Field(() => stringId2)
+    s2;
+}
+@ValueListFieldType({
+    getValues: () => [
+        new missingCaption('abc')
+    ]
+})
+class missingCaption {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+    caption;
+}
+@ValueListFieldType()
+class missingCaption2 {
+    id;
+    caption;
+    static item = new missingCaption2("abc");
+    constructor(id, caption) {
+        this.id = id;
+        this.caption = caption;
+    }
+}
+describe("Test Value List Items", () => {
+    it("require id", () => {
+        try {
+            const missingId = class {
+            };
+            ValueListFieldType({
+                getValues: () => [
+                    new missingId()
+                ]
+            })(missingId);
+            getValueList(missingId);
+            expect(true).toBe(false, "should have failed and not reached this since it's missing an id");
+        }
+        catch {
+        }
+    });
+    it("getValuesWorks Early", () => {
+        expect(getValueList(missingCaption).length).toBe(1);
+    });
+    it("caption is auto generated", () => {
+        expect(getValueList(missingCaption)[0].caption).toBe("Abc");
+    });
+    it("test caption 2", () => {
+        expect(getValueList(missingCaption2)[0].caption).toBe("Abc");
+    });
+    it("find by id", () => {
+        expect(ValueListInfo.get(missingCaption).byId("abc").caption).toBe("Abc");
+    });
+});

package/esm/core/src/tests/test-sql.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/core/src/tests/test-sql.spec.js

@@ -0,0 +1,170 @@
+import { WebSqlDataProvider } from '../data-providers/web-sql-data-provider';
+import { Remult } from '../context';
+import { SqlDatabase } from '../data-providers/sql-database';
+import { Categories } from './remult-3-entities';
+import { Entity, Fields } from '../remult3';
+import { testWebSqlImpl } from './frontend-database-tests-setup.spec';
+import { entityWithValidations } from '../shared-tests/entityWithValidations';
+import { dbNamesOf } from '../filter/filter-consumer-bridge-to-sql-request';
+describe("test sql database", () => {
+    let db = new SqlDatabase(new WebSqlDataProvider("test"));
+    let remult = new Remult();
+    remult.dataProvider = (db);
+    async function deleteAll() {
+        for (const c of await remult.repo(Categories).find()) {
+            await c._.delete();
+        }
+    }
+    it("test basics", async () => {
+        await deleteAll();
+        expect(await remult.repo(Categories).count()).toBe(0);
+        let c = remult.repo(Categories).create();
+        c.id = 1;
+        c.categoryName = "noam";
+        await c._.save();
+        expect(await remult.repo(Categories).count()).toBe(1);
+        let cats = await remult.repo(Categories).find();
+        expect(cats.length).toBe(1);
+        expect(cats[0].id).toBe(1);
+        expect(cats[0].categoryName).toBe("noam");
+    });
+    it("test transactions", async () => {
+        await deleteAll();
+        let sql = new WebSqlDataProvider("test");
+        const prev = SqlDatabase.LogToConsole;
+        SqlDatabase.LogToConsole = true;
+        try {
+            let db = new SqlDatabase({
+                createCommand: () => sql.createCommand(),
+                entityIsUsedForTheFirstTime: (e) => sql.entityIsUsedForTheFirstTime(e),
+                getLimitSqlSyntax: (a, b) => sql.getLimitSqlSyntax(a, b),
+                transaction: what => what(sql)
+            });
+            await db.transaction(async (dp) => {
+                const repo = new Remult(dp).repo(Categories);
+                expect(await repo.count({ categoryName: 'a' })).toBe(0);
+                let ok = false;
+                try {
+                    await dp.transaction(async () => { });
+                    ok = true;
+                }
+                catch {
+                }
+                expect(ok).toBe(false);
+            });
+        }
+        finally {
+            SqlDatabase.LogToConsole = false;
+        }
+    });
+    it("query after transaction should fail", async () => {
+        await deleteAll();
+        let sql = new WebSqlDataProvider("test");
+        let db = new SqlDatabase({
+            createCommand: () => sql.createCommand(),
+            entityIsUsedForTheFirstTime: (e) => sql.entityIsUsedForTheFirstTime(e),
+            getLimitSqlSyntax: (a, b) => sql.getLimitSqlSyntax(a, b),
+            transaction: what => what(sql)
+        });
+        let repo;
+        await db.transaction(async (dp) => {
+            repo = new Remult(dp).repo(Categories);
+        });
+        let ok = false;
+        try {
+            await repo.count({ categoryName: 'a' });
+            ok = true;
+        }
+        catch { }
+        expect(ok).toBe(false);
+    });
+    it("test column error", async () => {
+        await deleteAll();
+        await remult.repo(Categories).insert([{ categoryName: 'a', id: 1 }]);
+        try {
+            await remult.repo(testErrorInFromDb).find();
+        }
+        catch (err) {
+            expect(err.message).toContain("categoryName");
+        }
+    });
+    it("LogToConsole true", async () => {
+        await deleteAll();
+        SqlDatabase.LogToConsole = true;
+        console.info = jasmine.createSpy("log");
+        await remult.repo(Categories).insert([{ categoryName: 'a', id: 1 }]);
+        expect(console.info).toHaveBeenCalledWith(jasmine.objectContaining({
+            query: 'insert into Categories (CategoryID, categoryName) values (~1~, ~2~) returning CategoryID, categoryName, description, status',
+            arguments: { "~1~": 1, "~2~": 'a' },
+        }));
+        SqlDatabase.LogToConsole = false;
+    });
+    it("LogToConsole oneLiner", async () => {
+        await deleteAll();
+        SqlDatabase.LogToConsole = "oneLiner";
+        console.info = jasmine.createSpy("log");
+        await remult.repo(Categories).insert([{ categoryName: 'a', id: 1 }]);
+        expect(console.info).toHaveBeenCalledWith(jasmine.stringMatching('⚪'));
+        SqlDatabase.LogToConsole = false;
+    });
+    it("LogToConsole fn", async () => {
+        await deleteAll();
+        SqlDatabase.LogToConsole = (duration, query, args) => { };
+        SqlDatabase.LogToConsole = jasmine.createSpy("log");
+        await remult.repo(Categories).insert([{ categoryName: 'a', id: 1 }]);
+        expect(SqlDatabase.LogToConsole).toHaveBeenCalledWith(jasmine.anything(), 'insert into Categories (CategoryID, categoryName) values (~1~, ~2~) returning CategoryID, categoryName, description, status', jasmine.objectContaining({ "~1~": 1, "~2~": 'a' }));
+        SqlDatabase.LogToConsole = false;
+    });
+});
+@Entity("Categories")
+class testErrorInFromDb {
+    @Fields.integer({ dbName: 'CategoryID' })
+    id = 0;
+    @Fields.string({
+        valueConverter: {
+            fromDb: x => { throw 'error'; }
+        }
+    })
+    categoryName = '';
+}
+testWebSqlImpl("work with native sql", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const sql = SqlDatabase.getDb(remult);
+    const r = await sql.execute("select count(*) as c from " + repo.metadata.options.dbName);
+    expect(r.rows[0].c).toBe(4);
+}, false);
+testWebSqlImpl("work with native sql2", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const sql = WebSqlDataProvider.getDb(remult);
+    await new Promise((res) => {
+        sql.transaction(y => {
+            y.executeSql("select count(*) as c from " + repo.metadata.options.dbName, undefined, (_, r) => {
+                expect(r.rows[0].c).toBe(4);
+                res({});
+            });
+        });
+    });
+}, false);
+testWebSqlImpl("test getEntityDbNames", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const e = await dbNamesOf(repo);
+    expect(`select ${e.myId}, ${e.name} from ${e}`)
+        .toBe("select myId, name from entityWithValidations");
+}, false);
+testWebSqlImpl("test work with filter", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const e = await dbNamesOf(repo);
+    expect(`select ${e.myId}, ${e.name} from ${e} where ${await SqlDatabase.filterToRaw(repo, {
+        myId: [1, 3]
+    })}`)
+        .toBe("select myId, name from entityWithValidations where myId in (1,3)");
+}, false);
+testWebSqlImpl("test work with filter", async ({ remult, createEntity }) => {
+    const repo = await entityWithValidations.create4RowsInDp(createEntity);
+    const command = SqlDatabase.getDb(remult).createCommand();
+    const e = await dbNamesOf(repo);
+    expect(`select ${e.myId}, ${e.name} from ${e} where ${await SqlDatabase.filterToRaw(repo, {
+        myId: [1, 3]
+    }, command)}`)
+        .toBe("select myId, name from entityWithValidations where myId in (~1~,~2~)");
+}, false);

package/esm/core/src/tests/test-subscribe.spec.d.ts

@@ -0,0 +1 @@
+export {};