remult 0.22.2 → 0.22.3

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

@@ -1,306 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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

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

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

@@ -1,170 +0,0 @@
-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

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