remult 0.22.2 → 0.22.3

package/esm/core/src/tests/test-data-api/predefined-filter.spec.js

@@ -1,389 +0,0 @@
-import { TestDataApiResponse } from "../TestDataApiResponse";
-import { Done } from "../Done";
-import { createData } from "../createData";
-import { DataApi } from '../../data-api';
-import { isBackend, Remult } from '../../context';
-import { Categories as newCategories } from '../remult-3-entities';
-import { Entity as EntityDecorator } from '../../remult3';
-import { testAsIfOnBackend } from "../testHelper.spec";
-import { Filter } from "../../filter/filter-interfaces";
-describe("data api", () => {
-    let remult = new Remult();
-    it("getArray works with predefined filter", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            expect(data[0].id).toBe(2);
-            d.ok();
-        };
-        await api.getArray(t, undefined);
-        d.test();
-    });
-    it("get works with predefined filter", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        });
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.id).toBe(2);
-            d.ok();
-        };
-        await api.get(t, 2);
-        d.test();
-    });
-    it("get id  works with predefined filterand shouldnt return anything", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.notFound = () => {
-            d.ok();
-        };
-        await api.get(t, 1);
-        d.test();
-    });
-    it("delete id  works with predefined filterand shouldnt return anything", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.notFound = () => {
-            d.ok();
-        };
-        await api.delete(t, 1);
-        d.test();
-    });
-    it("delete id  works with predefined filterand shouldnt return anything", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.deleted = () => {
-            d.ok();
-        };
-        await api.delete(t, 2);
-        d.test();
-    });
-    it("put id  works with predefined filterand shouldnt return anything", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = () => {
-            d.ok();
-        };
-        await api.put(t, 2, { name: 'YAEL' });
-        d.test();
-    });
-    it("put id 1 works with predefined filterand shouldnt return anything", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.notFound = () => {
-            d.ok();
-        };
-        await api.put(t, 1, { name: 'YAEL' });
-        d.test();
-    });
-    it("put id 1 works with predefined filterand shouldnt return anything", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest2);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.notFound = () => {
-            d.ok();
-        };
-        await api.put(t, 1, { name: 'YAEL' });
-        d.test();
-    });
-    it("getArray works with predefined filter", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(0);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                if (x == c.create()._.fields.description.metadata.key)
-                    return "a";
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("getArray works with predefined filter1 ", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("getArray works with predefined filter 2", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest2);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("getArray works with predefined filter 3", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest3);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("getArray works with predefined filter 3 inherit", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest3Inherit);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("getArray works with predefined filter 4", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTest4);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("getArray works with predefined filter and inheritance", async () => {
-        let [c, remult] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        }, CategoriesForThisTestThatInherits);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.success = data => {
-            expect(data.length).toBe(1);
-            d.ok();
-        };
-        await api.getArray(t, {
-            get: x => {
-                return undefined;
-            }
-        });
-        d.test();
-    });
-    it("works with predefined Entity Filter", async () => {
-        let [c] = await createData(async (i) => {
-            await i(1, 'noam', 'a');
-            await i(2, 'yael', 'b');
-            await i(3, 'yoni', 'a');
-        });
-        expect((await c.findFirst({ id: 1 })).categoryName).toBe('noam');
-        expect((await c.findId(1)).categoryName).toBe('noam');
-    });
-});
-@EntityDecorator('categories', {
-    backendPrefilter: { description: 'b' }
-})
-class stam1 extends newCategories {
-}
-describe("", () => {
-    it("works with predefined Entity Filter", async () => {
-        testAsIfOnBackend(async () => {
-            let [c] = await createData(async (i) => {
-                await i(1, 'noam', 'a');
-                await i(2, 'yael', 'b');
-                await i(3, 'yoni', 'a');
-            }, stam1);
-            let r = await c.find();
-            expect(r.length).toBe(1, 'array length');
-            expect(r[0].id).toBe(2, 'value of first row');
-            expect(await c.count()).toBe(1, 'count');
-            expect(await c.findFirst({ id: 1 })).toBe(undefined, 'find first');
-            expect((await c.findFirst({ id: 1 }, { createIfNotFound: true }))._.isNew()).toBe(true, 'lookup ');
-        });
-    });
-});
-@EntityDecorator('categories', {
-    backendPrefilter: async () => ({ description: 'b' })
-})
-class stam2 extends newCategories {
-}
-describe("", () => {
-    it("works with predefined Entity Filter lambda", async () => {
-        testAsIfOnBackend(async () => {
-            let [c] = await createData(async (i) => {
-                await i(1, 'noam', 'a');
-                await i(2, 'yael', 'b');
-                await i(3, 'yoni', 'a');
-            }, stam2);
-            let r = await c.find();
-            expect(r.length).toBe(1, 'array length');
-            expect(r[0].id).toBe(2, 'value of first row');
-            expect(await c.count()).toBe(1, 'count');
-            expect(await c.findFirst({ id: 1 })).toBe(undefined, 'find first');
-            expect((await c.findFirst({ id: 1 }, { createIfNotFound: true }))._.isNew()).toBe(true, 'lookup ');
-        });
-    });
-});
-@EntityDecorator('categories', {
-    backendPrefilter: async () => ({ description: 'b' })
-})
-class stam3 extends newCategories {
-}
-it("backend filter only works on backend", async () => {
-    let [c] = await createData(async (i) => {
-        await i(1, 'noam', 'a');
-        await i(2, 'yael', 'b');
-        await i(3, 'yoni', 'a');
-    }, stam3);
-    expect(isBackend()).toBe(false);
-    let r = await c.find();
-    expect(r.length).toBe(3, 'array length');
-    expect(await c.count()).toBe(3, 'count');
-    await testAsIfOnBackend(async () => {
-        expect(await c.count()).toBe(1, 'count');
-        expect(await c.findFirst({ id: 1 })).toBe(undefined, 'find first');
-        expect((await c.findFirst({ id: 1 }, { createIfNotFound: true }))._.isNew()).toBe(true, 'lookup ');
-    });
-});
-@EntityDecorator(undefined, {
-    allowApiUpdate: true,
-    allowApiDelete: true,
-    apiPrefilter: { description: 'b' }
-})
-class CategoriesForThisTest extends newCategories {
-}
-@EntityDecorator(undefined, {
-    allowApiUpdate: true,
-    allowApiDelete: true,
-    apiPrefilter: () => ({ description: 'b' })
-})
-class CategoriesForThisTest2 extends newCategories {
-}
-@EntityDecorator(undefined, {
-    backendPrefilter: () => ({ categoryName: { $contains: 'a' } })
-})
-class CategoriesForThisTestThatInherits extends CategoriesForThisTest2 {
-}
-@EntityDecorator(undefined, {
-    allowApiUpdate: true,
-    allowApiDelete: true,
-    apiPrefilter: CategoriesForThisTest3.myFilter()
-})
-class CategoriesForThisTest3 extends newCategories {
-    static myFilter = Filter.createCustom(async (remult) => ({ description: 'b' }), "key");
-}
-@EntityDecorator(undefined, {})
-class CategoriesForThisTest3Inherit extends CategoriesForThisTest3 {
-}
-@EntityDecorator(undefined, {
-    allowApiUpdate: true,
-    allowApiDelete: true,
-    apiPrefilter: () => CategoriesForThisTest4.myFilter()
-})
-class CategoriesForThisTest4 extends newCategories {
-    static myFilter = Filter.createCustom(async (remult) => ({ description: 'b' }));
-}

package/esm/core/src/tests/test-data-api/test-put-with-validation.spec.d.ts

@@ -1,5 +0,0 @@
-export declare class ExceptionValidation {
-    id: number;
-    name: string;
-    name2: string;
-}

package/esm/core/src/tests/test-data-api/test-put-with-validation.spec.js

@@ -1,152 +0,0 @@
-import { TestDataApiResponse } from "../TestDataApiResponse";
-import { Done } from "../Done";
-import { createData } from "../createData";
-import { DataApi } from '../../data-api';
-import { Remult } from '../../context';
-import { Categories } from "../remult-3-entities";
-import { Entity, EntityBase, ValueListInfo, Fields, getEntityRef } from "../../remult3";
-import { InMemoryDataProvider } from "../../..";
-import { Status } from "../testModel/models";
-describe("data api", () => {
-    it("put with validations fails", async () => {
-        let [c, remult] = await createData(async (insert) => insert(1, 'noam'), CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.error = async (data) => {
-            expect(data.modelState.categoryName).toBe('invalid');
-            d.ok();
-        };
-        await api.put(t, 1, {
-            categoryName: 'noam 1'
-        });
-        d.test();
-        var x = await c.find({ where: { id: 1 } });
-        expect(x[0].categoryName).toBe('noam');
-    });
-    it("post with validation fails", async () => {
-        let [c, remult] = await createData(async () => { }, CategoriesForThisTest);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        let d = new Done();
-        t.error = async (data) => {
-            expect(data.modelState.categoryName).toBe('invalid');
-            d.ok();
-        };
-        await api.post(t, { id: 1, categoryName: 'noam 1' });
-        d.test();
-        expect((await c.find()).length).toBe(0);
-    });
-    it("allow column update based on new row only", async () => {
-        let type = class extends EntityBase {
-            id;
-            val;
-        };
-        Entity('allowcolumnupdatetest', { allowApiCrud: true })(type);
-        Fields.integer()(type.prototype, 'id');
-        Fields.string({
-            allowApiUpdate: (x, c) => x._.isNew()
-        })(type.prototype, 'val');
-        let remult = new Remult();
-        remult.dataProvider = (new InMemoryDataProvider());
-        let c = remult.repo(type);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        t.success = () => { };
-        t.created = () => { };
-        let d = new Done();
-        await api.post(t, {
-            id: 1,
-            val: 'noam'
-        });
-        await api.put(t, 1, {
-            val: 'yael'
-        });
-        var x = await c.find({ where: { id: 1 } });
-        expect(x[0].val).toBe('noam');
-    });
-    it("allow column update based on specific value", async () => {
-        let type = class extends EntityBase {
-            id;
-            val;
-        };
-        Entity('allowcolumnupdatetest', { allowApiCrud: true })(type);
-        Fields.integer()(type.prototype, 'id');
-        Fields.string({
-            allowApiUpdate: (x, c) => x.val != "yael"
-        })(type.prototype, 'val');
-        let remult = new Remult();
-        remult.dataProvider = (new InMemoryDataProvider());
-        let c = remult.repo(type);
-        expect(c.fields.val.apiUpdateAllowed({ val: 'yael' })).toBe(false);
-        expect(c.fields.val.apiUpdateAllowed({ val: 'yae' })).toBe(true);
-        var api = new DataApi(c, remult);
-        let t = new TestDataApiResponse();
-        t.success = () => { };
-        t.created = () => { };
-        let d = new Done();
-        await api.post(t, {
-            id: 1,
-            val: 'noam'
-        });
-        await api.put(t, 1, {
-            val: 'yael'
-        });
-        var x = await c.find({ where: { id: 1 } });
-        expect(x[0].val).toBe('yael');
-        await api.put(t, 1, {
-            val: 'yoni'
-        });
-        var x = await c.find({ where: { id: 1 } });
-        expect(x[0].val).toBe('yael');
-    });
-    it("test value list type", () => {
-        let x = ValueListInfo.get(Status);
-        expect(x.fieldTypeInDb).toBe("integer");
-    });
-});
-@Entity(undefined, {
-    allowApiUpdate: true,
-    allowApiInsert: true,
-    saving: (t) => {
-        if (t.categoryName.indexOf('1') >= 0)
-            t._.fields.categoryName.error = 'invalid';
-    }
-})
-class CategoriesForThisTest extends Categories {
-}
-describe("Test validation with exception", () => {
-    it("", async () => {
-        const repo = new Remult(new InMemoryDataProvider()).repo(ExceptionValidation);
-        let e = repo.create({ name: 'a', name2: 'b' });
-        try {
-            await repo.save(e);
-        }
-        catch (err) {
-            const info = err;
-            expect(info.modelState.name).toBe("say what?");
-            expect(getEntityRef(e).fields.name.error).toBe("say what?");
-            expect(info.modelState.name2).toBe("say what?2");
-            expect(getEntityRef(e).fields.name2.error).toBe("say what?2");
-        }
-    });
-});
-@Entity(undefined, {})
-export class ExceptionValidation {
-    @Fields.number()
-    id = 0;
-    @Fields.string({
-        validate: self => {
-            if (self.name.length < 5)
-                throw "say what?";
-        }
-    })
-    name = '';
-    @Fields.string({
-        validate: self => {
-            if (self.name.length < 5)
-                throw new Error("say what?2");
-        }
-    })
-    name2 = '';
-}

package/esm/core/src/tests/test-decorator-precedence.spec.d.ts

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

package/esm/core/src/tests/test-decorator-precedence.spec.js

@@ -1,38 +0,0 @@
-import { Remult } from '../context';
-import { Entity, EntityBase, Fields } from '../remult3';
-@Entity('my entity')
-class myEntity extends EntityBase {
-    @Fields.string()
-    @Fields.string({ caption: '123' })
-    a;
-    @Fields.string({ caption: '123' })
-    @Fields.string()
-    b;
-    @Fields.string((o, c) => o.caption = "456")
-    c;
-}
-describe("test decorator precedence", () => {
-    it("test basics", async () => {
-        let c = new Remult();
-        let r = c.repo(myEntity);
-        expect([...r.metadata.fields].length).toBe(3);
-        expect(r.metadata.fields.a.caption).toBe('123');
-        expect(r.metadata.fields.b.caption).toBe('123');
-        expect(r.metadata.fields.c.caption).toBe('456');
-    });
-    it("testit", () => {
-        let c = new Remult();
-        let r = c.repo(user).create();
-        expect(r.$.username.metadata.caption).toBe("Username");
-    });
-});
-@Entity('profile')
-class profile extends EntityBase {
-    @Fields.string()
-    username;
-}
-@Entity('user')
-class user extends profile {
-    @Fields.string()
-    email;
-}

package/esm/core/src/tests/test-default-value.spec.d.ts

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

package/esm/core/src/tests/test-default-value.spec.js

@@ -1,33 +0,0 @@
-import { Remult } from '../context';
-import { InMemoryDataProvider } from '../data-providers/in-memory-database';
-import { EntityBase, Entity, Fields } from '../remult3';
-describe("test default value", () => {
-    it("test basics", async () => {
-        let c = new Remult();
-        c.dataProvider = (new InMemoryDataProvider());
-        testDefaultValue.testVal = 1;
-        let r = c.repo(testDefaultValue).create();
-        expect(r.test).toBe(1);
-        expect(testDefaultValue.testVal).toBe(2);
-    });
-    it("test create without querying the value", async () => {
-        let c = new Remult();
-        c.dataProvider = (new InMemoryDataProvider());
-        testDefaultValue.testVal = 1;
-        let r = c.repo(testDefaultValue).create();
-        await r._.save();
-        let res = await c.repo(testDefaultValue).find({});
-        expect(res.length).toBe(1);
-        expect(testDefaultValue.testVal).toBe(2);
-        expect(res[0].test).toBe(1);
-    });
-});
-@Entity('testDefaultValue')
-class testDefaultValue extends EntityBase {
-    static testVal = 0;
-    code;
-    @Fields.integer({
-        defaultValue: () => testDefaultValue.testVal++
-    })
-    test;
-}

package/esm/core/src/tests/test-entity-inheritance.spec.d.ts

@@ -1,14 +0,0 @@
-import { EntityBase } from "../remult3";
-export declare class parent extends EntityBase {
-    id: number;
-    myField: string;
-    autoSavedField: string;
-}
-export declare class child extends parent {
-}
-export declare class child2 extends parent {
-}
-export declare class anError extends EntityBase {
-    id: number;
-    name: string;
-}