remult 0.21.1 → 0.22.0

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

@@ -0,0 +1,135 @@
+import { InMemoryDataProvider } from "../..";
+import { Remult } from "../context";
+import { Entity, EntityBase, Field, Fields } from "../remult3";
+import { Validators } from "../validators";
+describe("test subscribe", () => {
+    it("basics", async () => {
+        let repo = new Remult(new InMemoryDataProvider()).repo(myEntity);
+        for (const del of await repo.find()) {
+            await del.delete();
+        }
+        let state = {
+            title: '',
+            wasChanged: false,
+            isNew: false,
+            error: '',
+            titleError: ''
+        };
+        let i = repo.create();
+        let r = i._.subscribe(() => {
+            state.title = i.title;
+            state.wasChanged = i._.wasChanged();
+            state.isNew = i._.isNew();
+            state.error = i._.error;
+            state.titleError = i.$.title.error;
+        });
+        i.title = 'a';
+        expect(state.title).toBe('a');
+        i.title = 'ab';
+        expect(state.title).toBe("ab");
+        expect(state.wasChanged).toBe(true);
+        expect(state.isNew).toBe(true);
+        let x = i.save();
+        expect(i._.isLoading).toBe(true);
+        await x;
+        expect(i._.isLoading).toBe(false);
+        expect(state.title).toBe('ab');
+        expect(state.wasChanged).toBe(false);
+        expect(state.isNew).toBe(false);
+        i.$.title.error = 'error';
+        expect(state.titleError).toBe('error');
+        i._.error = "error";
+        expect(state.error).toBe('error');
+    });
+    it("observed", async () => {
+        let repo = new Remult(new InMemoryDataProvider()).repo(myEntity);
+        for (const del of await repo.find()) {
+            await del.delete();
+        }
+        let i = repo.create();
+        let observed = false;
+        i._.subscribe({
+            reportChanged: () => { },
+            reportObserved: () => observed = true
+        });
+        function testObserved(what) {
+            observed = false;
+            what();
+            expect(observed).toBe(true);
+        }
+        testObserved(() => { i.title.toString(); });
+        testObserved(() => { i.$.title.valueChanged(); });
+        testObserved(() => { i.isNew(); });
+        testObserved(() => { i._.wasChanged(); });
+    });
+    it("refInitWorks", async () => {
+        let repo = new Remult(new InMemoryDataProvider()).repo(myEntity);
+        for (const del of await repo.find()) {
+            await del.delete();
+        }
+        entityRefInitCount = 0;
+        let remultInitCount = 0;
+        Remult.entityRefInit = () => remultInitCount++;
+        let i = repo.create({ title: "a" });
+        expect(entityRefInitCount).toBe(1);
+        expect(remultInitCount).toBe(1);
+        await i.save();
+        expect(entityRefInitCount).toBe(1);
+        expect(remultInitCount).toBe(1);
+        Remult.entityRefInit = undefined;
+    });
+    it("test subscribe with many to one", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        const repo = remult.repo(entityWithManyToOne);
+        for (const del of await repo.find()) {
+            await del.delete();
+        }
+        let refRowA = await remult.repo(myEntity).create({ title: 'a' }).save();
+        let refRowB = await remult.repo(myEntity).create({ title: 'b' }).save();
+        let reflect = { title: '' };
+        let r = repo.create();
+        let sub = r._.subscribe(() => reflect.title = r.entity?.title);
+        r.entity = refRowA;
+        expect(reflect.title).toBe('a');
+        sub();
+        r.entity = refRowB;
+        expect(reflect.title).toBe('a');
+    });
+    it("test subscribe to field with many to one", async () => {
+        const remult = new Remult(new InMemoryDataProvider());
+        const repo = remult.repo(entityWithManyToOne);
+        for (const del of await repo.find()) {
+            await del.delete();
+        }
+        let refRowA = await remult.repo(myEntity).create({ title: 'a' }).save();
+        let refRowB = await remult.repo(myEntity).create({ title: 'b' }).save();
+        let reflect = { title: '' };
+        let r = repo.create();
+        let sub = r.$.entity.subscribe(() => reflect.title = r.entity?.title);
+        r.entity = refRowA;
+        expect(reflect.title).toBe('a');
+        sub();
+        r.entity = refRowB;
+        expect(reflect.title).toBe('a');
+    });
+});
+let entityRefInitCount = 0;
+@Entity("theEntity", {
+    allowApiCrud: true,
+    entityRefInit: () => entityRefInitCount++
+})
+class myEntity extends EntityBase {
+    @Fields.string({
+        validate: Validators.required
+    })
+    title = '';
+}
+@Entity("entityWithManyToOne", {
+    allowApiCrud: true
+})
+class entityWithManyToOne extends EntityBase {
+    @Fields.number()
+    id = 0;
+    @Field(() => myEntity)
+    entity;
+}

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

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

package/esm/core/src/tests/test-type-recovery.spec.js

@@ -0,0 +1,49 @@
+import { Remult } from "../context";
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { Entity, Fields } from "../remult3";
+import { describeClass } from "../remult3/DecoratorReplacer";
+describe("type recovery", () => {
+    const entity = class {
+        id = 0;
+        date = new Date();
+    };
+    describeClass(entity, Entity("x"), {
+        id: Fields.number(),
+        date: Fields.dateOnly({
+            validate: (_, ref) => ref.value.getFullYear() < 1980
+        })
+    });
+    let mem = new InMemoryDataProvider();
+    const repo = new Remult(mem).repo(entity);
+    beforeEach(async () => {
+        for (const item of await repo.find()) {
+            await repo.delete(item);
+        }
+    });
+    it("test insert works with Date", async () => {
+        let r = await repo.insert({ id: 0, date: '1976-06-16' });
+        expect(r.date.getFullYear()).toBe(1976);
+    });
+    it("test validate with Date", async () => {
+        let r = await repo.validate({ id: 0, date: '1976-06-16' });
+        expect(r).toBeUndefined();
+    });
+    it("test create", async () => {
+        let r = repo.create({ id: 0, date: '1976-06-16' });
+        expect(r.date.getFullYear()).toBe(1976);
+    });
+    it("test save works with Date", async () => {
+        let r = await repo.save({ date: '1976-06-16' });
+        expect(r.date.getFullYear()).toBe(1976);
+    });
+    it("test update using save", async () => {
+        await repo.insert({ id: 1, date: '1975-06-16' });
+        let r = await repo.save({ id: 1, date: '1976-06-16' });
+        expect(r.date.getFullYear()).toBe(1976);
+    });
+    it("test update ", async () => {
+        await repo.insert({ id: 1, date: '1975-06-16' });
+        let r = await repo.update(1, { date: '1976-06-16' });
+        expect(r.date.getFullYear()).toBe(1976);
+    });
+});

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

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

package/esm/core/src/tests/test-where-api.spec.js

@@ -0,0 +1,434 @@
+import { testRestDb } from './testHelper.spec';
+import { TestDataApiResponse } from "./TestDataApiResponse";
+import { Done } from "./Done";
+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 { insertFourRows } from './RowProvider.spec';
+import { Entity, EntityBase, Fields } from '../remult3';
+import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { customUrlToken, Filter } from '../filter/filter-interfaces';
+import { RestDataProvider } from '../data-providers/rest-data-provider';
+import { DataApi } from '../data-api';
+import { ArrayEntityDataProvider } from '../data-providers/array-entity-data-provider';
+import { dbNamesOf } from '../filter/filter-consumer-bridge-to-sql-request';
+import { entityForrawFilter } from './entityForCustomFilter';
+import { describeClass } from '../remult3/DecoratorReplacer';
+describe("test where stuff", () => {
+    let repo;
+    beforeAll(async (done) => {
+        [repo] = await insertFourRows();
+        done();
+    });
+    it("test in statement", async () => {
+        expect(await repo.count({ id: [undefined] })).toBe(0);
+        expect(await repo.count({ id: [1, undefined, 3] })).toBe(2);
+    });
+    it("test and", async () => {
+        expect(await repo.count({ categoryName: 'yoni' })).toBe(1);
+        expect(await repo.count({ categoryName: { $gte: 'yoni' } })).toBe(1);
+        expect(await repo.count({ id: 1 })).toBe(1);
+        expect(await repo.count({ id: 1, categoryName: 'yoni' })).toBe(0);
+        expect(await repo.count({ id: 1, $and: [{ categoryName: 'yoni' }] })).toBe(0);
+        expect(await repo.count({ $and: [{ id: 1 }, { categoryName: 'yoni' }] })).toBe(0);
+    });
+    it("test two values", async () => {
+        expect(await repo.count({ $and: [{ id: 1 }, { id: 2 }] })).toBe(0);
+    });
+    it("test two values", async () => {
+        const json = await Filter.fromEntityFilter(repo.metadata, { $and: [{ id: 1 }, { id: 2 }] }).toJson();
+        expect(await repo.count(Filter.entityFilterFromJson(repo.metadata, json))).toBe(0);
+    });
+    it("test in and", async () => {
+        const json = await Filter.fromEntityFilter(repo.metadata, { $and: [{ id: [1, 2] }, { id: [2] }] }).toJson();
+        expect(await repo.count(Filter.entityFilterFromJson(repo.metadata, json))).toBe(1);
+    });
+    it("test basics", async () => {
+        let fo = {
+            where: { id: { ">=": 2 } }
+        };
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where] })).toBe(2);
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where] })).toBe(2);
+        expect(await repo.count({ $and: [fo.where], id: { $lte: 3 } })).toBe(2);
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where] })).toBe(2);
+    });
+    it("test basics_2", async () => {
+        let fo = {
+            where: { id: { $gte: 2 } }
+        };
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where, undefined] })).toBe(2);
+    });
+    it("test basics_2_2", async () => {
+        let fo = {
+            where: { id: { ">=": 2 } }
+        };
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where] })).toBe(2);
+    });
+    it("test basics_2_3", async () => {
+        let fo = {
+            where: { id: { ">=": 2 } }
+        };
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where] })).toBe(2);
+    });
+    it("test basics_2_1", async () => {
+        let fo = {
+            where: { id: { $gte: 2 } }
+        };
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where, undefined] })).toBe(2);
+    });
+    it("test basics_3", async () => {
+        let fo = {
+            where: { id: { ">=": 2 } }
+        };
+        expect(await repo.count({ id: { $lte: 3 }, $and: [fo.where] })).toBe(2);
+    });
+});
+describe("custom filter", () => {
+    it("test that it works", async () => {
+        let c = new Remult().repo(entityForrawFilter, new InMemoryDataProvider());
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        expect(await (c.count(entityForrawFilter.filter({ oneAndThree: true }))))
+            .toBe(2);
+    });
+    it("works with serialize filter", async () => {
+        let z = entityForrawFilter.oneAndThree();
+        let c = new Remult().repo(entityForrawFilter, new InMemoryDataProvider());
+        let json = (await Filter.fromEntityFilter(c.metadata, entityForrawFilter.oneAndThree())).toJson();
+        expect(json).toEqual({
+            $custom$oneAndThree: {}
+        });
+        let json3 = Filter.entityFilterToJson(c.metadata, Filter.entityFilterFromJson(c.metadata, json));
+        expect(json3).toEqual(json);
+    });
+    it("test that it works", () => testRestDb(async ({ remult }) => {
+        let c = remult.repo(entityForrawFilter);
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        expect(await (c.count(entityForrawFilter.oneAndThree()))).toBe(2);
+        expect((await (c.findFirst(entityForrawFilter.testNumericValue(2)))).id).toBe(2);
+        expect((await (c.findFirst(entityForrawFilter.testObjectValue({ val: 2 })))).id).toBe(2);
+    }));
+    ;
+    it("test that it works with sql", async () => {
+        let w = new WebSqlDataProvider("testWithFilter");
+        let c = new Remult().repo(entityForrawFilter, new SqlDatabase(w));
+        await w.dropTable(c.metadata);
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        const e = await dbNamesOf(c.metadata);
+        expect(await (c.count(SqlDatabase.rawFilter(async (x) => x.sql = e.id + ' in (' + x.addParameterAndReturnSqlToken(1) + "," + x.addParameterAndReturnSqlToken(3, c.metadata.fields.id) + ")"))))
+            .toBe(2);
+        expect(await (c.count(entityForrawFilter.filter({ dbOneOrThree: true })))).toBe(2);
+    });
+    it("test that it works with arrayFilter", async () => {
+        let c = new Remult().repo(entityForrawFilter, new InMemoryDataProvider());
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        expect(await (c.count(ArrayEntityDataProvider.rawFilter(x => x.id == 1 || x.id == 3))))
+            .toBe(2);
+        expect(await (c.count(entityForrawFilter.filter({ dbOneOrThree: true })))).toBe(2);
+    });
+    it("test or and promise in translate", async () => {
+        let c = new Remult().repo(entityForrawFilter, new InMemoryDataProvider());
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        "".toString();
+        expect(await (c.count({
+            $or: [entityForrawFilter.filter({ dbOneOrThree: true }), { id: 4 }]
+        }))).toBe(3);
+    });
+    it("test sent in api", async () => {
+        let ok = new Done();
+        let z = new RestDataProvider(() => ({
+            httpClient: {
+                delete: () => undefined,
+                get: async (url) => {
+                    ok.ok();
+                    expect(url).toBe('/entityForrawFilter?%24custom%24filter=%7B%22oneAndThree%22%3Atrue%7D&__action=count');
+                    return { count: 0 };
+                },
+                post: () => undefined,
+                put: () => undefined,
+            }, url: ''
+        }));
+        let c = new Remult();
+        c.dataProvider = (z);
+        await c.repo(entityForrawFilter).count(entityForrawFilter.filter({ oneAndThree: true }));
+        ok.test();
+    });
+    it("test order by on rest request", async () => {
+        let ok = new Done();
+        let c = new Remult(new RestDataProvider(() => ({
+            httpClient: {
+                delete: () => undefined,
+                get: async (url) => {
+                    ok.ok();
+                    expect(url).toBe('/Categories?_sort=categoryName%2Cid');
+                    return [];
+                },
+                post: () => undefined,
+                put: () => undefined,
+            }, url: ''
+        })));
+        await c.repo(Categories).find({
+            orderBy: {
+                categoryName: "asc",
+                id: "asc"
+            }
+        });
+        ok.test();
+    });
+    it("test order by on rest request", async () => {
+        let ok = new Done();
+        let c = new Remult(new RestDataProvider(() => ({
+            httpClient: {
+                delete: () => undefined,
+                get: async (url) => {
+                    ok.ok();
+                    expect(url).toBe('/Categories?_sort=categoryName%2Cid&_order=asc%2Cdesc');
+                    return [];
+                },
+                post: () => undefined,
+                put: () => undefined,
+            }, url: ''
+        })));
+        await c.repo(Categories).find({
+            orderBy: {
+                categoryName: "asc",
+                id: "desc"
+            }
+        });
+        ok.test();
+    });
+    it("test find id on api", async () => {
+        let myEntity = class {
+            id = 0;
+            title = '';
+        };
+        describeClass(myEntity, Entity("test", {
+            defaultOrderBy: {
+                title: "asc"
+            }
+        }), {
+            id: Fields.integer(),
+            title: Fields.string()
+        });
+        let ok = new Done();
+        let z = new RestDataProvider(() => ({
+            httpClient: {
+                delete: () => undefined,
+                get: async (url) => {
+                    ok.ok();
+                    expect(url).toBe('/test?id=8');
+                    return [];
+                },
+                post: () => undefined,
+                put: () => undefined,
+            }, url: ''
+        }));
+        let c = new Remult();
+        c.dataProvider = (z);
+        await c.repo(myEntity).findId(8);
+        ok.test();
+    });
+    it("test that api reads custom correctly", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (new InMemoryDataProvider());
+        let c = remult.repo(entityForrawFilter);
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        var api = new DataApi(c, remult);
+        let t = new TestDataApiResponse();
+        let d = new Done();
+        t.success = data => {
+            expect(data.count).toBe(2);
+            d.ok();
+        };
+        await api.count(t, {
+            get: x => {
+                if (x == customUrlToken + "filter")
+                    return "{\"oneAndThree\":true}";
+                return undefined;
+            }
+        });
+        d.test();
+    });
+    it("test that api reads custom correctly 2", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (new InMemoryDataProvider());
+        let c = remult.repo(entityForrawFilter);
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        var api = new DataApi(c, remult);
+        let t = new TestDataApiResponse();
+        let d = new Done();
+        t.success = data => {
+            expect(data.count).toBe(2);
+            d.ok();
+        };
+        await api.count(t, {
+            get: x => {
+                if (x == customUrlToken)
+                    return;
+                return undefined;
+            }
+        }, {
+            "$custom$filter": {
+                "oneAndThree": true
+            }
+        });
+        d.test();
+    });
+    it("test that api reads custom correctly 3", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (new InMemoryDataProvider());
+        let c = remult.repo(entityForrawFilter);
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        var api = new DataApi(c, remult);
+        let t = new TestDataApiResponse();
+        let d = new Done();
+        t.success = data => {
+            expect(data.count).toBe(2);
+            d.ok();
+        };
+        await api.count(t, {
+            get: x => {
+                if (x == customUrlToken)
+                    return;
+                return undefined;
+            }
+        }, {
+            "$custom$filter": {
+                "oneAndThree": true
+            }
+        });
+        d.test();
+    });
+    it("test that api reads custom correctly and translates to db", async () => {
+        let remult = new Remult();
+        remult.dataProvider = (new InMemoryDataProvider());
+        let c = remult.repo(entityForrawFilter);
+        for (let id = 0; id < 5; id++) {
+            await c.create({ id }).save();
+        }
+        var api = new DataApi(c, remult);
+        let t = new TestDataApiResponse();
+        let d = new Done();
+        t.success = data => {
+            expect(data.count).toBe(2);
+            d.ok();
+        };
+        await api.count(t, {
+            get: x => {
+                if (x == customUrlToken + "filter")
+                    return "{\"dbOneOrThree\":true}";
+                return undefined;
+            }
+        });
+        d.test();
+    });
+});
+function x(what) {
+}
+//reproduce typescript bug with recursive types
+x({});
+@Entity('tasks')
+class task extends EntityBase {
+    @Fields.string()
+    title = '';
+    @Fields.boolean()
+    completed = false;
+}
+@Entity('taskWithNull')
+class taskWithNull extends EntityBase {
+    @Fields.string()
+    title = '';
+    @Fields.boolean({ allowNull: true })
+    completed;
+}
+describe("missing fields are added in array column", async () => {
+    it("not allow null", async () => {
+        let db = new InMemoryDataProvider();
+        db.rows['tasks'] = [{
+                title: 't1'
+            },
+            {
+                title: 't2',
+                completed: true
+            },
+            {
+                title: 't3'
+            }];
+        let r = new Remult();
+        r.dataProvider = (db);
+        let rep = r.repo(task);
+        expect((await rep.find({ orderBy: { completed: "asc", title: 'asc' } })).map(x => x.title)).toEqual(["t1", "t3", "t2"]);
+        expect(await rep.count({ completed: false })).toBe(2);
+        let t = (await rep.findFirst({ title: 't1' }));
+        expect(t.completed).toBe(false);
+        t.completed = undefined;
+        await t.save();
+        expect(t.completed).toBe(false);
+        t.completed = null;
+        await t.save();
+        expect(t.completed).toBe(false);
+        t = rep.create({ title: '4' });
+        await t.save();
+        expect(t.completed).toBe(false);
+    });
+    it("allow  null", async () => {
+        let db = new InMemoryDataProvider();
+        db.rows['taskWithNull'] = [{
+                title: 't1'
+            },
+            {
+                title: 't2',
+                completed: true
+            },
+            {
+                title: 't3'
+            }];
+        let r = new Remult();
+        r.dataProvider = (db);
+        let rep = r.repo(taskWithNull);
+        expect((await rep.find({ orderBy: { completed: "asc", title: "asc" } })).map(x => x.title)).toEqual(["t1", "t3", "t2"]);
+        expect(await rep.count({ completed: false })).toBe(0);
+        let t = (await rep.findFirst({ title: 't1' }));
+        expect(t.completed).toBe(null);
+        t.completed = undefined;
+        await t.save();
+        expect(t.completed).toBe(null);
+        t.completed = null;
+        await t.save();
+        expect(t.completed).toBe(null);
+        t = rep.create({ title: '4' });
+        await t.save();
+        expect(t.completed).toBe(null);
+    });
+    it("test api with and", () => {
+        let x = {
+            title: "abc",
+            $and: []
+        };
+        x.$and.push({});
+        let y = { $and: [x, x] };
+    });
+    it("test api with and", () => {
+        let x = {
+            $and: []
+        };
+        x.$and.push({});
+        let z = x;
+    });
+});

package/esm/core/src/tests/testHelper.spec.d.ts

@@ -0,0 +1,36 @@
+import './frontend-database-tests-setup.spec';
+import { Remult } from "../context";
+import { DataApi } from "../data-api";
+import { DataProvider, EntityDataProvider } from "../data-interfaces";
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { EntityMetadata } from "../remult3";
+export declare function itForEach<T>(name: string, arrayOfT: T[], runAsync: (item: T) => Promise<any>): void;
+export declare function fitForEach<T>(name: string, arrayOfT: T[], runAsync: (item: T) => Promise<any>): void;
+export declare function testAsIfOnBackend(what: () => Promise<any>): Promise<void>;
+export declare const ActionTestConfig: {
+    db: InMemoryDataProvider;
+};
+export declare function testSql(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testInMemoryDb(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testRestDb(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare function testAllDataProviders(runAsync: (db: {
+    db: DataProvider;
+    remult: Remult;
+}) => Promise<void>): Promise<void>;
+export declare class MockRestDataProvider implements DataProvider {
+    private remult;
+    constructor(remult: Remult);
+    getEntityDataProvider(metadata: EntityMetadata<any>): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    isProxy: boolean;
+}
+export declare function createMockHttpDataProvider(dataApi: DataApi<any>): import("../data-interfaces").RestDataProviderHttpProvider;