remult 0.22.1 → 0.22.3

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

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

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

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

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

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

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

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

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