remult 0.22.2 → 0.22.3

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

@@ -1,489 +0,0 @@
-import { ActionTestConfig, testAsIfOnBackend } from './testHelper.spec';
-import { Remult, isBackend } from '../context';
-import { prepareArgsToSend, Controller, BackendMethod } from '../server-action';
-import { Field, Entity, getFields, ValueListFieldType, Fields, IdEntity } from '../remult3';
-import { remult, RemultProxy } from '../remult-proxy';
-import { describeClass } from '../remult3/DecoratorReplacer';
-import { InMemoryDataProvider } from '../data-providers/in-memory-database';
-@ValueListFieldType()
-export class myType {
-    what;
-    static x = new myType((n) => 'x' + n);
-    static y = new myType((n) => 'y' + n);
-    id;
-    constructor(what) {
-        this.what = what;
-    }
-}
-@Entity('testEntity')
-class testEntity extends IdEntity {
-    @Fields.string()
-    name;
-    @BackendMethod({ allowed: false })
-    async forbidden() {
-    }
-}
-@Controller('1')
-class testBasics {
-    remult;
-    constructor(remult) {
-        this.remult = remult;
-    }
-    @Fields.date()
-    theDate;
-    @Field(() => myType)
-    myType;
-    @Field(() => testEntity)
-    myEntity;
-    @BackendMethod({ allowed: true })
-    async testDate() {
-        return this.theDate.getFullYear();
-    }
-    @BackendMethod({ allowed: true })
-    async testDataType(n) {
-        return this.myType.what(n);
-    }
-    @BackendMethod({ allowed: false })
-    async forbidden() {
-    }
-    @BackendMethod({ allowed: true })
-    async sendEntityAsParamter() {
-        return this.myEntity.name;
-    }
-    static test;
-    @Fields.string({
-        validate: (y, x) => {
-            if (y.a == "errorc") {
-                x.error = "error on client";
-            }
-            else if (y.a == "error on server" && isBackend()) {
-                x.error = "error on server";
-            }
-        }
-    })
-    a;
-    @BackendMethod({ allowed: true })
-    async doIt() {
-        let result = 'hello ' + this.a;
-        this.a = 'yael';
-        return {
-            onServer: isBackend(),
-            result
-        };
-    }
-    @BackendMethod({ allowed: true })
-    static async sf(name, remult) {
-        return {
-            onServer: isBackend(),
-            result: 'hello ' + name
-        };
-    }
-    @BackendMethod({ allowed: true })
-    static async testDate(d) {
-        return d.getFullYear();
-    }
-    @BackendMethod({ allowed: false })
-    static async testForbidden2() {
-    }
-    @BackendMethod({ allowed: true })
-    static async testDataType(d, n) {
-        return d.what(n);
-    }
-    @BackendMethod({ allowed: true })
-    static async getValFromServer(remult) {
-        return (await remult.repo(testEntity).findFirst()).name;
-    }
-    static async staticBackendMethodWithoutDecorator() {
-        return isBackend();
-    }
-    static async staticBackendMethodWithoutDecoratorWithRemult(remult) {
-        return (await remult.repo(testEntity).findFirst()).name;
-    }
-    async backendMethodWithoutDecorator() {
-        return isBackend();
-    }
-    async backendMethodWithoutDecoratorWithRemult(remult) {
-        return (await remult.repo(testEntity).findFirst()).name + this.a;
-    }
-    @BackendMethod({ allowed: true })
-    static async sendEntityAsParamter(entity) {
-        if (entity === null)
-            return "null";
-        return entity.name;
-    }
-    @BackendMethod({ allowed: true })
-    static async syntaxError() {
-        let z = undefined;
-        return z.toString();
-    }
-    @BackendMethod({ allowed: true })
-    async syntaxError() {
-        let z = undefined;
-        return z.toString();
-    }
-}
-describeClass(testBasics, undefined, undefined, {
-    staticBackendMethodWithoutDecorator: BackendMethod({ allowed: true })
-});
-describeClass(testBasics, undefined, undefined, {
-    staticBackendMethodWithoutDecoratorWithRemult: BackendMethod({ allowed: true, paramTypes: [Remult] })
-});
-describeClass(testBasics, undefined, {
-    backendMethodWithoutDecorator: BackendMethod({ allowed: true })
-});
-describeClass(testBasics, undefined, {
-    backendMethodWithoutDecoratorWithRemult: BackendMethod({ allowed: true, paramTypes: [Remult] })
-});
-class Stam {
-    @BackendMethod({ allowed: false })
-    static async testForbidden1() {
-        console.log("I am in forbidden");
-    }
-}
-describe("test Server Controller basics", () => {
-    let c = new Remult();
-    c.dataProvider = (ActionTestConfig.db);
-    beforeEach(async (done) => {
-        await Promise.all((await c.repo(testEntity).find()).map(x => x.delete()));
-        done();
-    });
-    it("forbidden static backend", async () => {
-        let ok = true;
-        try {
-            await Stam.testForbidden1();
-            ok = false;
-        }
-        catch (err) {
-            expect(err.httpStatusCode).toBe(403);
-        }
-        expect(ok).toBe(true);
-    });
-    it("forbidden static backend", async () => {
-        let ok = true;
-        try {
-            await testBasics.testForbidden2();
-            ok = false;
-        }
-        catch (err) {
-            expect(err.httpStatusCode).toBe(403);
-        }
-        expect(ok).toBe(true);
-    });
-    it("forbidden static backend", async () => {
-        let ok = true;
-        try {
-            await testBasics.testForbidden2();
-            ok = false;
-        }
-        catch (err) {
-            expect(err.httpStatusCode).toBe(403);
-        }
-        expect(ok).toBe(true);
-    });
-    it("forbidden backend", async () => {
-        let ok = true;
-        try {
-            await new testBasics(c).forbidden();
-            ok = false;
-        }
-        catch (err) {
-            expect(err.httpStatusCode).toBe(403);
-        }
-        expect(ok).toBe(true);
-    });
-    it("forbidden entity", async () => {
-        let ok = true;
-        try {
-            await remult.repo(testEntity).create().forbidden();
-            ok = false;
-        }
-        catch (err) {
-            expect(err.httpStatusCode).toBe(403);
-        }
-        expect(ok).toBe(true);
-    });
-    it("test error", async () => {
-        try {
-            await testBasics.syntaxError();
-        }
-        catch (err) {
-            expect(err.message).toContain("Cannot read prop");
-        }
-    });
-    it("test error server method", async () => {
-        try {
-            await new testBasics(c).syntaxError();
-        }
-        catch (err) {
-            expect(err.message).toContain("Cannot read prop");
-        }
-    });
-    it("send entity to server ", async () => {
-        let e = await c.repo(testEntity).create({ name: 'test' }).save();
-        expect(await testBasics.sendEntityAsParamter(e)).toBe('test');
-    });
-    it("send entity to server ", async () => {
-        expect(await testBasics.sendEntityAsParamter(null)).toBe('null');
-    });
-    it("send entity to server prepare args to send ", async () => {
-        let e = await c.repo(testEntity).create({ name: 'test' }).save();
-        expect(prepareArgsToSend([testEntity], [e])[0]).toBe(e.id);
-    });
-    it("data is saved on server", async () => {
-        await c.repo(testEntity).create({ name: 'test' }).save();
-        expect(await testBasics.getValFromServer()).toBe('test');
-    });
-    it("new backend method syntax static method with remult", async () => {
-        await c.repo(testEntity).create({ name: 'test' }).save();
-        expect(await testBasics.staticBackendMethodWithoutDecoratorWithRemult()).toBe('test');
-    });
-    it("new backend method syntax static method", async () => {
-        expect(await testBasics.staticBackendMethodWithoutDecorator()).toBe(true);
-    });
-    it("new backend method syntax 1", async () => {
-        expect(await new testBasics(undefined).backendMethodWithoutDecorator()).toBe(true);
-    });
-    it("new backend method syntax 2", async () => {
-        await c.repo(testEntity).create({ name: 'test' }).save();
-        const z = new testBasics(undefined);
-        z.a = 'x';
-        expect(await z.backendMethodWithoutDecoratorWithRemult()).toBe('testx');
-    });
-    it("test backend method caller", async () => {
-        const c = new Remult({
-            url: "xx", httpClient: {
-                delete: () => undefined,
-                get: () => undefined,
-                post: async (url, data) => {
-                    expect(url).toBe("xx/sf");
-                    expect(data.args[0]).toEqual("noam");
-                    return { data: { result: "hello noam" } };
-                },
-                put: () => undefined
-            }
-        });
-        const r = (await c.call(testBasics.sf, undefined, "noam"));
-        expect(r.result).toBe("hello noam");
-    });
-    it("test backend method caller with proxy", async () => {
-        const p = new RemultProxy();
-        {
-            const c = new Remult({
-                url: "xx", httpClient: {
-                    delete: () => undefined,
-                    get: () => undefined,
-                    post: async (url, data) => {
-                        expect(url).toBe("xx/sf");
-                        expect(data.args[0]).toEqual("noam");
-                        return { data: { result: "hello noam" } };
-                    },
-                    put: () => undefined
-                }
-            });
-            p.remultFactory = () => c;
-        }
-        const r = (await p.call(testBasics.sf, undefined, "noam"));
-        expect(r.result).toBe("hello noam");
-    });
-    it("test backend method instance method", async () => {
-        const c = new Remult({
-            url: "xx", httpClient: {
-                delete: () => undefined,
-                get: () => undefined,
-                post: async (url, data) => {
-                    expect(url).toBe("xx/1/doIt");
-                    return { result: { result: "hello noam" }, fields: {} };
-                },
-                put: () => undefined
-            }
-        });
-        const b = new testBasics(remult);
-        const r = (await c.call(b.doIt, b));
-        expect(r.result).toBe("hello noam");
-    });
-    it("test backend method instance method with proxy", async () => {
-        const c = new Remult({
-            url: "xx", httpClient: {
-                delete: () => undefined,
-                get: () => undefined,
-                post: async (url, data) => {
-                    expect(url).toBe("xx/1/doIt");
-                    return { result: { result: "hello noam" }, fields: {} };
-                },
-                put: () => undefined
-            }
-        });
-        const p = new RemultProxy();
-        p.remultFactory = () => c;
-        const b = new testBasics(remult);
-        const r = (await p.call(b.doIt, b));
-        expect(r.result).toBe("hello noam");
-    });
-    it("test server function", async () => {
-        let r = await testBasics.sf("noam");
-        expect(r.onServer).toBe(true);
-        expect(r.result).toBe('hello noam');
-    });
-    it("test server function on server", async () => {
-        await testAsIfOnBackend(async () => {
-            let r = await testBasics.sf("noam");
-            expect(r.onServer).toBe(true);
-            expect(r.result).toBe('hello noam');
-        });
-    });
-    it("test server Method Date", async () => {
-        let tb = new testBasics(c);
-        tb.theDate = new Date(1976, 6, 16);
-        expect(await tb.testDate()).toBe(1976);
-    });
-    it("test server Method Date on server", async () => {
-        let tb = new testBasics(c);
-        tb.theDate = new Date(1976, 6, 16);
-        await testAsIfOnBackend(async () => {
-            expect(await tb.testDate()).toBe(1976);
-        });
-    });
-    it("test server Method myType", async () => {
-        let tb = new testBasics(c);
-        tb.myType = myType.y;
-        expect(await tb.testDataType(7)).toBe('y7');
-    });
-    it("test server method entity", async () => {
-        let e = await c.repo(testEntity).create({ name: 'test3' }).save();
-        let tb = new testBasics(c);
-        tb.myEntity = e;
-        expect(await tb.sendEntityAsParamter()).toBe('test3');
-    });
-    it("test server function Date", async () => {
-        let r = await testBasics.testDate(new Date(1976, 6, 16));
-        expect(r).toBe(1976);
-    });
-    it("test server function custom type", async () => {
-        let r = await testBasics.testDataType(myType.y, 2);
-        expect(r).toBe('y2');
-    });
-    it("test server method", async () => {
-        let x = new testBasics(new Remult());
-        x.a = 'Noam';
-        let r = await x.doIt();
-        expect(r.onServer).toBe(true);
-        expect(r.result).toBe('hello Noam');
-        expect(x.a).toBe("yael");
-    });
-    it("test validation method", async () => {
-        let x = new testBasics(new Remult());
-        x.a = 'errorc';
-        let happened = false;
-        try {
-            let r = await x.doIt();
-            happened = true;
-        }
-        catch (err) {
-            expect(err.modelState.a).toBe("error on client");
-            expect(getFields(x).a.error).toBe("error on client");
-        }
-        expect(happened).toBe(false);
-    });
-    it("test validation on server", async () => {
-        let x = new testBasics(new Remult());
-        x.a = "error on server";
-        let happened = false;
-        try {
-            let r = await x.doIt();
-            happened = true;
-        }
-        catch (err) {
-            expect(err.modelState.a).toBe("error on server");
-            expect(getFields(x).a.error).toBe("error on server");
-        }
-        expect(happened).toBe(false);
-    });
-    it("test static backend method ", async () => {
-        const myClass = class {
-            static async doSomething2222() {
-                return isBackend().toString();
-            }
-        };
-        describeClass(myClass, undefined, undefined, {
-            doSomething2222: BackendMethod({ allowed: true, apiPrefix: 'myPrefix' }),
-        });
-        expect(await myClass.doSomething2222()).toBe("true");
-    });
-    it("test backend method with adhoc entity", async () => {
-        const myClass = class {
-            id = 0;
-            name = '';
-            async doSomething() {
-                return this.name + isBackend();
-            }
-        };
-        describeClass(myClass, Controller('addHocController'), {
-            id: Fields.autoIncrement(),
-            name: Fields.string(),
-            doSomething: BackendMethod({ allowed: true }),
-        });
-        const x = new myClass();
-        x.name = "123";
-        expect(await x.doSomething()).toBe("123true");
-    });
-    it("test static backend method with adhoc controller", async () => {
-        const myClass = class {
-            id = 0;
-            name = '';
-            static async adHockDoSomething() {
-                return isBackend();
-            }
-        };
-        describeClass(myClass, Controller('addHocController1'), {
-            id: Fields.autoIncrement(),
-            name: Fields.string()
-        }, {
-            adHockDoSomething: BackendMethod({ allowed: true }),
-        });
-        expect(await myClass.adHockDoSomething()).toBe(true);
-    });
-    it("test remult proxy for repository", async () => {
-        let remult1 = new Remult(new InMemoryDataProvider());
-        await remult1.repo(testEntity).insert({ name: "a" });
-        let remult2 = new Remult(new InMemoryDataProvider());
-        let remultProxy = new RemultProxy();
-        let repo = remultProxy.repo(testEntity);
-        remultProxy.remultFactory = () => remult1;
-        expect(await repo.count()).toBe(1);
-        remultProxy.remultFactory = () => remult2;
-        expect(await repo.count()).toBe(0);
-        let z = await repo.save({ name: "b" });
-        expect(z.name).toBe("b");
-        expect(await repo.count()).toBe(1);
-        remultProxy.remultFactory = () => remult1;
-        expect(await repo.find({
-            where: {
-                name: "b"
-            }
-        })).toEqual([]);
-    });
-});
-describe("controller with extends ", () => {
-    it("test inheritance in controllers", async () => {
-        let c = new child();
-        c.childField = 'c';
-        c.parentField = 'p';
-        let r = await c.run();
-        expect(r.c).toBe('c');
-        expect(r.p).toBe('p');
-    });
-});
-@Controller("parent")
-class parent {
-    @Fields.string()
-    parentField;
-}
-@Controller("child")
-class child extends parent {
-    @Fields.string()
-    childField;
-    @BackendMethod({ allowed: true })
-    run() {
-        return { p: this.parentField, c: this.childField };
-    }
-}

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

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

package/esm/core/src/tests/test-server-expressions.spec.js

@@ -1,178 +0,0 @@
-import { Remult } from '../context';
-import { InMemoryDataProvider } from '../data-providers/in-memory-database';
-import { dbNamesOf } from '../filter/filter-consumer-bridge-to-sql-request';
-import { remult } from '../remult-proxy';
-import { Entity, EntityBase, Fields } from '../remult3';
-import { describeClass } from '../remult3/DecoratorReplacer';
-import { actionInfo } from '../server-action';
-describe("test server expression value", () => {
-    beforeEach(() => actionInfo.runningOnServer = true);
-    afterEach(() => actionInfo.runningOnServer = false);
-    it("test basics create", async () => {
-        let c = new Remult();
-        c.dataProvider = (new InMemoryDataProvider());
-        testServerExpression.testVal = 1;
-        testServerExpression.testVal2 = 11;
-        let r = c.repo(testServerExpression).create();
-        r.code = 5;
-        await r._.save();
-        expect(r.test).toBe(1);
-        expect(r.testPromise).toBe(11);
-        expect(testServerExpression.testVal).toBe(2);
-        expect(testServerExpression.testVal2).toBe(12);
-    });
-    it("test basics find", async () => {
-        let c = new Remult();
-        c.dataProvider = (new InMemoryDataProvider());
-        testServerExpression.testVal = 1;
-        testServerExpression.testVal2 = 11;
-        let r = c.repo(testServerExpression).create();
-        r.code = 5;
-        await r._.save();
-        testServerExpression.testVal = 1;
-        testServerExpression.testVal2 = 11;
-        r = (await c.repo(testServerExpression).find({}))[0];
-        expect(r.test).toBe(1);
-        expect(r.testPromise).toBe(11);
-        expect(testServerExpression.testVal).toBe(2);
-        expect(testServerExpression.testVal2).toBe(12);
-    });
-    it("test doesnt calc on client", async () => {
-        actionInfo.runningOnServer = false;
-        let c = new Remult();
-        c.dataProvider = (new InMemoryDataProvider());
-        testServerExpression.testVal = 1;
-        testServerExpression.testVal2 = 11;
-        let r = c.repo(testServerExpression).create();
-        r.code = 5;
-        await r._.save();
-        expect(r.test).toBe(undefined);
-        expect(r.testPromise).toBe(undefined);
-        expect(testServerExpression.testVal).toBe(1);
-        expect(testServerExpression.testVal2).toBe(11);
-    });
-    it("test basics find doesnt calc on client", async () => {
-        actionInfo.runningOnServer = false;
-        let c = new Remult();
-        c.dataProvider = (new InMemoryDataProvider());
-        let r = c.repo(testServerExpression).create();
-        r.code = 5;
-        await r._.save();
-        testServerExpression.testVal = 1;
-        testServerExpression.testVal2 = 11;
-        r = (await c.repo(testServerExpression).find({}))[0];
-        expect(r.test).toBe(undefined);
-        expect(r.testPromise).toBe(undefined);
-        expect(testServerExpression.testVal).toBe(1);
-        expect(testServerExpression.testVal2).toBe(11);
-    });
-    it("test uuid", async () => {
-        const e = class {
-            id = '';
-            num = 0;
-        };
-        describeClass(e, Entity("x"), {
-            id: Fields.uuid(),
-            num: Fields.number()
-        });
-        const repo = new Remult(new InMemoryDataProvider()).repo(e);
-        let item = await repo.insert({ num: 1 });
-        expect(item.id.length).toBe(36, item.id);
-        item = await repo.insert({ id: '123', num: 2 });
-        expect(item.id).toBe('123');
-    });
-    it("test cuid", async () => {
-        const e = class {
-            id = '';
-            num = 0;
-        };
-        describeClass(e, Entity("x"), {
-            id: Fields.cuid(),
-            num: Fields.number()
-        });
-        const repo = new Remult(new InMemoryDataProvider()).repo(e);
-        let item = await repo.insert({ num: 1 });
-        expect(item.id.length).toBe(24, item.id);
-        item = await repo.insert({ id: '123', num: 2 });
-        expect(item.id).toBe('123');
-    });
-    it("test createdAt", async () => {
-        const e = class {
-            id = 1;
-            createdAt;
-            updatedAt;
-            val = 0;
-        };
-        describeClass(e, Entity("x"), {
-            id: Fields.autoIncrement(),
-            createdAt: Fields.createdAt(),
-            updatedAt: Fields.updatedAt(),
-            val: Fields.number()
-        });
-        const repo = new Remult(new InMemoryDataProvider()).repo(e);
-        let item = await repo.insert({});
-        expect(item.createdAt.toDateString()).toBe(new Date().toDateString());
-        expect(Math.abs((item.updatedAt.valueOf() - item.createdAt.valueOf()))).toBeLessThan(5);
-        let c = item.createdAt;
-        await new Promise(res => setTimeout(() => {
-            res({});
-        }, 10));
-        item = await repo.save({ ...item, val: 3 });
-        expect(item.val).toBe(3);
-        expect(item.createdAt).toEqual(c);
-        expect(item.createdAt).not.toEqual(item.updatedAt);
-    });
-    if (false)
-        it("test recursive db names", async () => {
-            const myClass = class {
-                a;
-                b;
-                c;
-                d;
-                e;
-                f;
-            };
-            describeClass(myClass, Entity("test-recursive-db-names"), {
-                a: Fields.string(),
-                b: Fields.string({ dbName: 'bb' }),
-                c: Fields.string({ sqlExpression: () => "cc" }),
-                d: Fields.string({ sqlExpression: async (e) => await e.fields.c.getDbName() + "dd" }),
-                e: Fields.string({
-                    sqlExpression: async (e) => {
-                        const n = await dbNamesOf(e);
-                        return n.c + "ee";
-                    }
-                }),
-                f: Fields.string({
-                    sqlExpression: async (e) => {
-                        const n = await dbNamesOf(e);
-                        return n.f + "ff";
-                    }
-                })
-            });
-            const r = await dbNamesOf(remult.repo(myClass));
-            expect(r.a).toBe('a');
-            expect(r.b).toBe('bb');
-            expect(r.c).toBe('cc');
-            expect(r.d).toBe('ccdd');
-            expect(r.e).toBe("ccee");
-            expect(r.f).toBe("Recursive getDbName call for field 'f'. ff");
-            const z = await dbNamesOf(remult.repo(myClass).metadata);
-            expect(z.a).toBe('a');
-            const zz = await dbNamesOf(myClass);
-            expect(zz.a).toBe('a');
-            const zzz = await dbNamesOf(testServerExpression);
-            expect(zzz.code).toBe('code');
-        });
-});
-@Entity('testServerExpression')
-class testServerExpression extends EntityBase {
-    static testVal = 1;
-    static testVal2 = 10;
-    @Fields.integer()
-    code;
-    @Fields.integer({ serverExpression: () => testServerExpression.testVal++ })
-    test;
-    @Fields.integer({ serverExpression: () => Promise.resolve(testServerExpression.testVal2++) })
-    testPromise;
-}

package/esm/core/src/tests/test-server-method-on-entity.spec.d.ts

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