remult 0.22.2 → 0.22.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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