remult 0.21.1 → 0.22.0

package/esm/core/src/tests/test-non-active-record.spec.d.ts

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

package/esm/core/src/tests/test-non-active-record.spec.js

@@ -0,0 +1,66 @@
+import { Remult } from "../context";
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { Entity, Fields } from "../remult3";
+import { Validators } from "../validators";
+@Entity("nonActiveRecord", {})
+class taskNonActiveRecord {
+    @Fields.uuid()
+    id;
+    @Fields.string({
+        validate: Validators.required
+    })
+    title = '';
+    @Fields.boolean()
+    completed = false;
+}
+describe("test non active record", () => {
+    let remult = new Remult(new InMemoryDataProvider());
+    let repo = remult.repo(taskNonActiveRecord);
+    beforeEach(() => {
+        remult = new Remult(new InMemoryDataProvider());
+        repo = remult.repo(taskNonActiveRecord);
+    });
+    it("test save of new row validation", async () => {
+        let item = { ...new taskNonActiveRecord() };
+        let ok = true;
+        try {
+            await repo.save(item);
+            ok = false;
+        }
+        catch (err) {
+            expect(err?.modelState?.title).toContain("empty");
+            expect(item.id).toBeUndefined();
+        }
+        expect(ok).toBe(true);
+    });
+    it("test save of existing row validation", async () => {
+        let item = { ...await repo.insert({ title: 'test' }), title: '' };
+        let ok = true;
+        try {
+            await repo.save(item);
+            ok = false;
+        }
+        catch (err) {
+            expect(err?.modelState?.title).toContain("empty");
+        }
+        expect(ok).toBe(true);
+    });
+    it("test save doesn't return non row elements", async () => {
+        let item = { ...await repo.insert({ title: 'test' }), title: 'test1', changed: true };
+        item = await repo.save(item);
+        expect(item.changed).toBe(undefined);
+    });
+    it("delete works with non active record", async () => {
+        let item = await repo.save({ title: 'a' });
+        await repo.insert({ title: 'b' });
+        expect(repo.getEntityRef(item).isNew()).toBe(false);
+        await repo.delete({ ...item });
+        expect(await repo.count()).toBe(1);
+    });
+    it("test save doesn't return the messed up object", async () => {
+        var x = { ...new taskNonActiveRecord(), title: 'a', changed: true };
+        x = await repo.insert(x);
+        expect(x.changed).toBe(undefined);
+        expect(x.id.length > 1).toBe(true);
+    });
+});

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

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

package/esm/core/src/tests/test-object-column.spec.js

@@ -0,0 +1,189 @@
+import { WebSqlDataProvider } from '../data-providers/web-sql-data-provider';
+import { Remult } from '../context';
+import { SqlDatabase } from '../data-providers/sql-database';
+import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { Field, Entity, EntityBase, FieldType, Fields, IdEntity } from '../remult3';
+import { entityFilterToJson, Filter } from '../filter/filter-interfaces';
+import { assign } from '../../assign';
+describe("test object column", () => {
+    var wsql = new WebSqlDataProvider("test");
+    let db = new SqlDatabase(wsql);
+    let remult = new Remult();
+    remult.dataProvider = (db);
+    async function deleteAll() {
+        let e = remult.repo(ObjectColumnTest).metadata;
+        await wsql.dropTable(e);
+        await wsql.createTable(e);
+    }
+    it("test that changes to inner items are monitored", async () => {
+        await deleteAll();
+        var x = remult.repo(ObjectColumnTest).create({ id: 1, col: { firstName: 'yael', lastName: 'katri' } });
+        await x.save();
+        x.col.lastName = 'honig';
+        expect(x.$.col.valueChanged()).toBe(true);
+        expect(x._.wasChanged()).toBe(true);
+        await x.save();
+        expect(x.$.col.valueChanged()).toBe(false);
+        expect(x._.wasChanged()).toBe(false);
+        expect(x.col.lastName).toBe("honig");
+        x = await remult.repo(ObjectColumnTest).findFirst();
+        expect(x.col.lastName).toBe("honig");
+    });
+    it("test basics with wsql", async () => {
+        await deleteAll();
+        var x = remult.repo(ObjectColumnTest).create();
+        x.id = 1;
+        x.col = {
+            firstName: 'noam',
+            lastName: 'honig'
+        };
+        await x.save();
+        x = await remult.repo(ObjectColumnTest).findFirst();
+        expect(x.col.firstName).toBe('noam');
+        x = await remult.repo(ObjectColumnTest).findFirst({ col: { $contains: "yael" } });
+        expect(x).toBeUndefined();
+        x = await remult.repo(ObjectColumnTest).findFirst({ col: { $contains: "noam" } });
+        expect(x.id).toBe(1);
+        expect(x.phone1).toBeNull();
+        expect(x.phone2).toBeNull();
+        expect(x.phone3).toBeNull();
+        let sqlr = (await db.execute('select phone1,phone2,phone3 from ' + (await x._.repository.metadata.getDbName()))).rows[0];
+        expect(sqlr.phone1).toBe('');
+        expect(sqlr.phone2).toBeNull();
+        expect(sqlr.phone3).toBe('');
+        assign(x, {
+            phone1: new Phone("123"),
+            phone2: new Phone("456"),
+            phone3: new Phone("789")
+        });
+        await x.save();
+        sqlr = (await db.execute('select phone1,phone2,phone3 from ' + (await x._.repository.metadata.getDbName()))).rows[0];
+        expect(sqlr.phone1).toBe('123');
+        expect(sqlr.phone2).toBe('456');
+        expect(sqlr.phone3).toBe('789');
+        await assign(x, {
+            phone1: null,
+            phone2: null,
+            phone3: null
+        }).save();
+        sqlr = (await db.execute('select phone1,phone2,phone3 from ' + (await x._.repository.metadata.getDbName()))).rows[0];
+        expect(sqlr.phone1).toBe('');
+        expect(sqlr.phone2).toBeNull();
+        expect(sqlr.phone3).toBe('');
+    });
+    it("test contains on custom type", async () => {
+        await deleteAll();
+        await remult.repo(ObjectColumnTest).create({
+            id: 1,
+            col: { firstName: 'noam', lastName: 'honig' },
+            phone1: new Phone("1234")
+        }).save();
+        await remult.repo(ObjectColumnTest).create({
+            id: 2,
+            col: { firstName: 'noam', lastName: 'honig' },
+            phone1: new Phone("5678")
+        }).save();
+        let r = remult.repo(ObjectColumnTest).metadata;
+        expect(await remult.repo(ObjectColumnTest).count({ phone1: { $contains: "23" } })).toBe(1);
+        expect(await remult.repo(ObjectColumnTest).count(Filter.entityFilterFromJson(r, entityFilterToJson(r, { phone1: { $contains: "23" } })))).toBe(1);
+    });
+    it("test basics with json", async () => {
+        var mem = new InMemoryDataProvider();
+        var c = new Remult();
+        c.dataProvider = (mem);
+        var x = c.repo(ObjectColumnTest).create();
+        x.id = 1;
+        x.col = {
+            firstName: 'noam',
+            lastName: 'honig'
+        };
+        await x.save();
+        x = await c.repo(ObjectColumnTest).findFirst();
+        expect(x.col.firstName).toBe('noam');
+        expect(mem.rows[x._.repository.metadata.key][0].col).toEqual({
+            firstName: 'noam',
+            lastName: 'honig'
+        });
+    });
+    it("test string[]", async () => {
+        await deleteAll();
+        let x = await remult.repo(ObjectColumnTest).create({
+            id: 1,
+            col: { firstName: 'noam', lastName: 'honig' }
+        }).save();
+        expect(x.tags).toBe(undefined);
+        expect(x.tags2).toBe(null);
+        x.tags = ["a", "b"];
+        await x.save();
+        expect(x.tags).toEqual(["a", "b"]);
+        let sqlr = (await db.execute('select tags,tags2 from ' + (await x._.repository.metadata.getDbName()))).rows[0];
+        expect(sqlr.tags).toBe(JSON.stringify(["a", "b"]));
+        expect(sqlr.tags2).toBeNull();
+    });
+    //
+});
+class Phone {
+    phone;
+    constructor(phone) {
+        this.phone = phone;
+    }
+}
+@FieldType({
+    valueConverter: {
+        fromJson: x => x ? new Phone4(x) : null,
+        toJson: x => x ? x.phone : ''
+    }
+})
+class Phone4 {
+    phone;
+    constructor(phone) {
+        this.phone = phone;
+    }
+}
+@Entity('objectColumnTest')
+class ObjectColumnTest extends EntityBase {
+    @Fields.integer()
+    id;
+    @Fields.object()
+    col;
+    @Field(() => Phone, {
+        valueConverter: {
+            fromJson: x => x ? new Phone(x) : null,
+            toJson: x => x ? x.phone : ''
+        }
+    })
+    phone1;
+    @Field(() => Phone, {
+        valueConverter: {
+            fromJson: x => x ? new Phone(x) : null,
+            toJson: x => x ? x.phone : null
+        },
+        allowNull: true
+    })
+    phone2;
+    @Field(() => Phone, {
+        valueConverter: {
+            fromJson: x => x ? new Phone(x) : null,
+            toJson: x => x ? x.phone : ''
+        }
+    })
+    phone3;
+    @Field(() => Phone4)
+    phone4;
+    @Fields.object()
+    tags;
+    @Fields.object({ allowNull: true })
+    tags2;
+}
+it("Test original values address defaults", async () => {
+    let r = new Remult();
+    let c = r.repo(somethingWithDefaults).create();
+    expect(c.name).toBe("noam");
+    expect(c.$.name.value).toBe("noam");
+    expect(c.$.name.originalValue).toBe('noam');
+});
+@Entity('somethingWithDefaults', {})
+class somethingWithDefaults extends IdEntity {
+    @Fields.string()
+    name = 'noam';
+}

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

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

package/esm/core/src/tests/test-paged-foreach.spec.js

@@ -0,0 +1,328 @@
+import { createData } from "./createData";
+import { Remult, queryConfig } from '../context';
+import { Entity, EntityBase, Fields } from '../remult3';
+import { Categories } from './remult-3-entities';
+import { Sort } from '../sort';
+import { CompoundIdField } from '../column';
+import { entityFilterToJson } from '../filter/filter-interfaces';
+import { testRestDb } from "./testHelper.spec";
+describe("test paged foreach ", () => {
+    queryConfig.defaultPageSize = 2;
+    it("basic foreach with where", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        let i = 0;
+        for await (const x of c.query({ where: { categoryName: { $gte: "n" } } })) {
+            expect(x.id).toBe([1, 2, 3, 4][i++]);
+        }
+        expect(i).toBe(4);
+    });
+    it("basic foreach with where 2", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        let i = 0;
+        for await (const x of c.query({
+            where: { categoryName: { ">=": "n" } }
+        })) {
+            expect(x.id).toBe([1, 2, 3, 4][i++]);
+        }
+        expect(i).toBe(4);
+    });
+    it("basic foreach with order by", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        let i = 0;
+        for await (const x of c.query({
+            orderBy: { categoryName: "asc" }
+        })) {
+            expect(x.id).toBe([5, 1, 4, 2, 3][i++]);
+        }
+        expect(i).toBe(5);
+        expect((await c.findFirst({}, {
+            orderBy: { categoryName: "asc" }
+        })).id).toBe(5);
+    });
+    it("basic foreach with order by desc", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        let i = 0;
+        for await (const x of c.query({
+            orderBy: { categoryName: "desc" }
+        })) {
+            expect(x.id).toBe([3, 2, 4, 1, 5][i++]);
+        }
+        expect(i).toBe(5);
+    });
+    it("iterate", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        var i = 0;
+        for await (const x of c.query()) {
+            expect(x.id).toBe(++i);
+        }
+        expect(i).toBe(5);
+    });
+    it("paginate", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        let p = await c.query().paginator();
+        expect(p.items.length).toBe(2);
+        expect(await p.count()).toBe(5);
+        expect(p.items.map(x => x.id)).toEqual([1, 2]);
+        expect(p.hasNextPage).toBe(true);
+        p = await p.nextPage();
+        expect(p.items.map(x => x.id)).toEqual([3, 4]);
+        expect(p.hasNextPage).toBe(true);
+        p = await p.nextPage();
+        expect(p.items.map(x => x.id)).toEqual([5]);
+        expect(p.hasNextPage).toBe(false);
+    });
+    it("paginate3", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'aoam');
+            await insert(2, 'bael');
+            await insert(3, 'coni');
+            await insert(4, 'dhay');
+            await insert(5, 'edo');
+        });
+        let p = await c.query({ where: { $or: [{ categoryName: { $contains: "" } }, { categoryName: { $contains: "" } }] }, orderBy: { categoryName: "asc" } }).paginator();
+        expect(p.items.length).toBe(2);
+        expect(await p.count()).toBe(5);
+        expect(p.items.map(x => x.id)).toEqual([1, 2]);
+        expect(p.hasNextPage).toBe(true);
+        p = await p.nextPage();
+        expect(p.items.map(x => x.id)).toEqual([3, 4]);
+        expect(p.hasNextPage).toBe(true);
+        p = await p.nextPage();
+        expect(p.items.map(x => x.id)).toEqual([5]);
+        expect(p.hasNextPage).toBe(false);
+    });
+    it("paginate2", async () => {
+        testRestDb(async ({ remult }) => {
+            let c = remult.repo(Categories);
+            await c.insert([
+                { id: 1, categoryName: 'aoam' },
+                { id: 2, categoryName: 'bael' }
+            ]);
+            await c.insert({ id: 3, categoryName: 'coni' });
+            await c.insert({ id: 4, categoryName: 'dhay' });
+            await c.insert({ id: 5, categoryName: 'edo' });
+            let p = await c.query({ where: { $or: [{ categoryName: { $contains: "" } }, { categoryName: { $contains: "" } }] }, orderBy: { categoryName: "asc" } }).paginator();
+            expect(p.items.length).toBe(2);
+            expect(await p.count()).toBe(5);
+            expect(p.items.map(x => x.id)).toEqual([1, 2]);
+            expect(p.hasNextPage).toBe(true);
+            p = await p.nextPage();
+            expect(p.items.map(x => x.id)).toEqual([3, 4]);
+            expect(p.hasNextPage).toBe(true);
+            p = await p.nextPage();
+            expect(p.items.map(x => x.id)).toEqual([5]);
+            expect(p.hasNextPage).toBe(false);
+        });
+    });
+    it("paginate", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        let p = await c.query({
+            pageSize: 3
+        });
+        expect((await p.getPage()).map(x => x.id)).toEqual([1, 2, 3]);
+        expect((await p.getPage(2)).map(x => x.id)).toEqual([4, 5]);
+    });
+    it("paginate on boundries", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+        });
+        let p = await c.query().paginator();
+        expect(p.items.length).toBe(2);
+        expect(await p.count()).toBe(4);
+        expect(p.items.map(x => x.id)).toEqual([1, 2]);
+        expect(p.hasNextPage).toBe(true);
+        p = await p.nextPage();
+        expect(p.items.map(x => x.id)).toEqual([3, 4]);
+        expect(p.hasNextPage).toBe(true);
+        p = await p.nextPage();
+        expect(p.items.map(x => x.id)).toEqual([]);
+        expect(p.hasNextPage).toBe(false);
+    });
+    it("test toArray", async () => {
+        let [c] = await createData(async (insert) => {
+            await insert(1, 'noam');
+            await insert(2, 'yael');
+            await insert(3, 'yoni');
+            await insert(4, 'shay');
+            await insert(5, 'ido');
+        });
+        var i = 0;
+        for (const x of await c.query({ pageSize: 10 }).getPage()) {
+            expect(x.id).toBe(++i);
+        }
+        expect(i).toBe(5);
+    });
+    it("test make sort unique", async () => {
+        let remult = new Remult();
+        let e = remult.repo(Categories);
+        function test(orderBy, ...sort) {
+            let z = { ...orderBy };
+            let s = Sort.createUniqueEntityOrderBy(e.metadata, orderBy);
+            let expected = {};
+            for (const c of sort) {
+                expected[c.key] = "asc";
+            }
+            expect(s).toEqual(expected);
+            expect(orderBy).toEqual(z);
+        }
+        test({ id: "asc" }, e.metadata.fields.id);
+        test({ categoryName: "asc" }, e.metadata.fields.categoryName, e.metadata.fields.id);
+    });
+    it("unique sort and  compound id", async () => {
+        let remult = new Remult();
+        let eDefs = remult.repo(theTable).metadata;
+        let e = eDefs.fields;
+        function test(orderBy, ...sort) {
+            let s = Sort.createUniqueEntityOrderBy(eDefs, orderBy);
+            let expected = {};
+            for (const c of sort) {
+                expected[c.key] = "asc";
+            }
+            expect(s).toEqual(expected);
+        }
+        test({ b: "asc", c: "asc" }, e.b, e.c, e.a);
+        test({ a: "asc", b: "asc" }, e.a, e.b);
+        test({ a: "asc" }, e.a, e.b);
+        test({ b: "asc" }, e.b, e.a);
+        test({ c: "asc" }, e.c, e.a, e.b);
+    });
+    it("create rows after filter compound id", async () => {
+        let remult = new Remult();
+        let eDefs = remult.repo(theTable);
+        let e = eDefs.create();
+        e.a = 'a';
+        e.b = 'b';
+        e.c = 'c';
+        async function test(orderBy, expectedWhere) {
+            expect(JSON.stringify(await entityFilterToJson(eDefs.metadata, await eDefs.createAfterFilter(orderBy, e)))).toEqual(JSON.stringify(await entityFilterToJson(eDefs.metadata, expectedWhere)));
+        }
+        test({ a: "asc" }, { a: { $gt: 'a' } });
+        test({ a: "desc" }, { a: { $lt: 'a' } });
+        test({ a: "asc", b: "asc" }, {
+            $or: [
+                { a: { $gt: 'a' } },
+                { a: 'a', b: { $gt: 'b' } }
+            ]
+        });
+    });
+    it("create rows after filter, values are frozen when filter is created", async () => {
+        let remult = new Remult();
+        let eDefs = remult.repo(theTable);
+        let e = eDefs.create();
+        e.a = 'a';
+        e.b = 'b';
+        e.c = 'c';
+        let f = await eDefs.createAfterFilter({ a: "asc", b: "asc" }, e);
+        e.a = '1';
+        e.b = '2';
+        expect(JSON.stringify(await entityFilterToJson(eDefs.metadata, f))).toEqual(JSON.stringify(await entityFilterToJson(eDefs.metadata, {
+            $or: [
+                { a: { $gt: 'a' } },
+                { a: 'a', b: { $gt: 'b' } }
+            ]
+        })));
+    });
+    it("serialize filter with or", async () => {
+        let remult = new Remult();
+        let eDefs = remult.repo(theTable);
+        let e = eDefs.create();
+        async function test(expectedWhere, expected) {
+            expect(JSON.stringify(await entityFilterToJson(eDefs.metadata, expectedWhere))).toEqual(JSON.stringify(expected));
+        }
+        await test({
+            $or: [
+                {
+                    a: 'a',
+                    b: { $gt: 'b' }
+                },
+                {
+                    a: { $gt: 'a' }
+                }
+            ]
+        }, {
+            OR: [
+                {
+                    a: 'a',
+                    "b.gt": 'b'
+                },
+                {
+                    "a.gt": 'a'
+                }
+            ]
+        });
+        await test({
+            a: 'a',
+            b: { $gt: 'b' }
+        }, {
+            a: 'a',
+            "b.gt": 'b'
+        });
+        await test({
+            $or: [
+                { a: 'a' },
+                { b: { $gt: 'b' } }
+            ]
+        }, {
+            OR: [
+                { a: 'a' },
+                { "b.gt": 'b' }
+            ]
+        });
+    });
+});
+@Entity('', {
+    id: t => new CompoundIdField(t.a, t.b)
+})
+class theTable extends EntityBase {
+    @Fields.string()
+    a;
+    @Fields.string()
+    b;
+    @Fields.string()
+    c;
+}

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

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

package/esm/core/src/tests/test-remult-angular.spec.js

@@ -0,0 +1,23 @@
+import { DataControl } from '../../../angular/interfaces';
+import { DataControl2Component } from '../../../angular/src/angular/data-control/data-control2.component';
+import { RemultAngularPluginsService } from '../../../angular/src/angular/RemultAngularPluginsService';
+import { Fields, getFields } from '../remult3';
+class classWithColumn {
+    static click;
+    @DataControl({
+        click: (r) => classWithColumn.click = r
+    })
+    @Fields.string()
+    a = '';
+    _ = getFields(this);
+}
+describe("remult angular", () => {
+    it("stand alone data control", async () => {
+        let dc = new DataControl2Component(new RemultAngularPluginsService(), undefined);
+        let c = new classWithColumn();
+        c.a = '1';
+        dc.field = c._.a;
+        dc.click();
+        expect(classWithColumn.click.a).toBe('1');
+    });
+});

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

@@ -0,0 +1,7 @@
+export declare class myType {
+    what: (n: number) => string;
+    static x: myType;
+    static y: myType;
+    id: any;
+    constructor(what: (n: number) => string);
+}