remult 0.14.7 → 0.14.8

package/esm/src/server-action.js

@@ -0,0 +1,365 @@
+import 'reflect-metadata';
+import { Remult, allEntities, classHelpers, ClassHelper, MethodHelper, setControllerSettings } from './context';
+import { SqlDatabase } from './data-providers/sql-database';
+import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef } from './remult3';
+export class Action {
+    constructor(actionUrl, queue, allowed) {
+        this.actionUrl = actionUrl;
+        this.queue = queue;
+        this.allowed = allowed;
+    }
+    async run(pIn) {
+        let r = await Action.provider.post(Remult.apiBaseUrl + '/' + this.actionUrl, pIn);
+        let p = r;
+        if (p && p.queuedJobId) {
+            let progress = actionInfo.startBusyWithProgress();
+            try {
+                let runningJob;
+                await actionInfo.runActionWithoutBlockingUI(async () => {
+                    while (!runningJob || !runningJob.done) {
+                        if (runningJob)
+                            await new Promise(res => setTimeout(() => {
+                                res(undefined);
+                            }, 200));
+                        runningJob = await Action.provider.post(Remult.apiBaseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId });
+                        if (runningJob.progress) {
+                            progress.progress(runningJob.progress);
+                        }
+                    }
+                });
+                if (runningJob.error)
+                    throw runningJob.error;
+                progress.progress(1);
+                return runningJob.result;
+            }
+            finally {
+                progress.close();
+            }
+        }
+        else
+            return r;
+    }
+    __register(reg) {
+        reg(this.actionUrl, this.queue, this.allowed, async (d, req, res) => {
+            try {
+                var r = await this.execute(d, req, res);
+                res.success(r);
+            }
+            catch (err) {
+                if (err instanceof ForbiddenError)
+                    res.forbidden();
+                else
+                    res.error(err);
+            }
+        });
+    }
+}
+Action.apiUrlForJobStatus = 'jobStatusInQueue';
+class ForbiddenError extends Error {
+    constructor() {
+        super("Forbidden");
+    }
+}
+export class myServerAction extends Action {
+    constructor(name, types, options, originalMethod) {
+        super(name, options.queue, options.allowed);
+        this.types = types;
+        this.options = options;
+        this.originalMethod = originalMethod;
+    }
+    async execute(info, remult, res) {
+        let result = { data: {} };
+        let ds = remult._dataSource;
+        await ds.transaction(async (ds) => {
+            remult.setDataProvider(ds);
+            if (!remult.isAllowedForInstance(undefined, this.options.allowed))
+                throw new ForbiddenError();
+            info.args = await prepareReceivedArgs(this.types, info.args, remult, ds, res);
+            try {
+                result.data = await this.originalMethod(info.args);
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        return result;
+    }
+}
+export const actionInfo = {
+    allActions: [],
+    runningOnServer: false,
+    runActionWithoutBlockingUI: (what) => { return what(); },
+    startBusyWithProgress: () => ({
+        progress: (percent) => { },
+        close: () => { }
+    })
+};
+export const serverActionField = Symbol('serverActionField');
+const methodHelpers = new Map();
+const classOptions = new Map();
+export function Controller(key) {
+    return function (target) {
+        let r = target;
+        classOptions.set(r, { key });
+        setControllerSettings(target, { key });
+        return target;
+    };
+}
+/** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
+export function BackendMethod(options) {
+    return (target, key, descriptor) => {
+        if (target.prototype !== undefined) {
+            var originalMethod = descriptor.value;
+            var types = Reflect.getMetadata("design:paramtypes", target, key);
+            // if types are undefined - you've forgot to set: "emitDecoratorMetadata":true
+            let serverAction = new myServerAction(key, types, options, args => originalMethod.apply(undefined, args));
+            descriptor.value = async function (...args) {
+                if (!actionInfo.runningOnServer) {
+                    args = prepareArgsToSend(types, args);
+                    if (options.blockUser === false) {
+                        return await actionInfo.runActionWithoutBlockingUI(async () => (await serverAction.run({ args })).data);
+                    }
+                    else
+                        return (await serverAction.run({ args })).data;
+                }
+                else
+                    return (await originalMethod.apply(undefined, args));
+            };
+            registerAction(target, descriptor);
+            descriptor.value[serverActionField] = serverAction;
+            return descriptor;
+        }
+        var types = Reflect.getMetadata("design:paramtypes", target, key);
+        let x = classHelpers.get(target.constructor);
+        if (!x) {
+            x = new ClassHelper();
+            classHelpers.set(target.constructor, x);
+        }
+        let mh = new MethodHelper();
+        methodHelpers.set(descriptor, mh);
+        x.methods.push(mh);
+        var originalMethod = descriptor.value;
+        let serverAction = {
+            __register(reg) {
+                let c = new Remult();
+                for (const constructor of mh.classes.keys()) {
+                    let controllerOptions = mh.classes.get(constructor);
+                    if (!controllerOptions.key) {
+                        controllerOptions.key = c.repo(constructor).metadata.key;
+                    }
+                    reg(controllerOptions.key + '/' + key, options ? options.queue : false, options.allowed, async (d, req, res) => {
+                        d.args = d.args.map(x => isCustomUndefined(x) ? undefined : x);
+                        let allowed = options.allowed;
+                        try {
+                            let remult = req;
+                            let ds = remult._dataSource;
+                            let r;
+                            await ds.transaction(async (ds) => {
+                                remult.setDataProvider(ds);
+                                d.args = await prepareReceivedArgs(types, d.args, remult, ds, res);
+                                if (allEntities.includes(constructor)) {
+                                    let repo = remult.repo(constructor);
+                                    let y;
+                                    if (d.rowInfo.isNewRow) {
+                                        y = repo.create();
+                                        let rowHelper = repo.getEntityRef(y);
+                                        await rowHelper._updateEntityBasedOnApi(d.rowInfo.data);
+                                    }
+                                    else {
+                                        let rows = await repo.find({
+                                            where: {
+                                                ...repo.metadata.idMetadata.getIdFilter(d.rowInfo.id),
+                                                $and: [repo.metadata.options.apiPrefilter]
+                                            }
+                                        });
+                                        if (rows.length != 1)
+                                            throw new Error("not found or too many matches");
+                                        y = rows[0];
+                                        await repo.getEntityRef(y)._updateEntityBasedOnApi(d.rowInfo.data);
+                                    }
+                                    if (!remult.isAllowedForInstance(y, allowed))
+                                        throw new ForbiddenError();
+                                    let defs = getEntityRef(y);
+                                    await defs.__validateEntity();
+                                    try {
+                                        r = {
+                                            result: await originalMethod.apply(y, d.args),
+                                            rowInfo: {
+                                                data: await defs.toApiJson(),
+                                                isNewRow: defs.isNew(),
+                                                wasChanged: defs.wasChanged(),
+                                                id: defs.getOriginalId()
+                                            }
+                                        };
+                                    }
+                                    catch (err) {
+                                        throw defs.catchSaveErrors(err);
+                                    }
+                                }
+                                else {
+                                    let y = new constructor(remult, ds);
+                                    let controllerRef = getControllerRef(y, remult);
+                                    await controllerRef._updateEntityBasedOnApi(d.fields);
+                                    if (!remult.isAllowedForInstance(y, allowed))
+                                        throw new ForbiddenError();
+                                    await controllerRef.__validateEntity();
+                                    try {
+                                        r = {
+                                            result: await originalMethod.apply(y, d.args),
+                                            fields: await controllerRef.toApiJson()
+                                        };
+                                    }
+                                    catch (err) {
+                                        throw controllerRef.catchSaveErrors(err);
+                                    }
+                                }
+                            });
+                            res.success(r);
+                        }
+                        catch (err) {
+                            res.error(err);
+                        }
+                    });
+                }
+            }
+        };
+        descriptor.value = async function (...args) {
+            if (!actionInfo.runningOnServer) {
+                let self = this;
+                args = prepareArgsToSend(types, args);
+                if (allEntities.includes(target.constructor)) {
+                    let defs = getEntityRef(self);
+                    await defs.__validateEntity();
+                    let classOptions = mh.classes.get(self.constructor);
+                    if (!classOptions.key) {
+                        classOptions.key = defs.repository.metadata.key + "_methods";
+                    }
+                    try {
+                        let r = await (new class extends Action {
+                            async execute(a, b) {
+                                throw ('should get here');
+                            }
+                        }(classOptions.key + "/" + key, options ? options.queue : false, options.allowed).run({
+                            args,
+                            rowInfo: {
+                                data: await defs.toApiJson(),
+                                isNewRow: defs.isNew(),
+                                wasChanged: defs.wasChanged(),
+                                id: defs.getOriginalId()
+                            }
+                        }));
+                        await defs._updateEntityBasedOnApi(r.rowInfo.data);
+                        return r.result;
+                    }
+                    catch (err) {
+                        defs.catchSaveErrors(err);
+                        throw err;
+                    }
+                }
+                else {
+                    let defs = getControllerRef(self, undefined);
+                    try {
+                        await defs.__validateEntity();
+                        let r = await (new class extends Action {
+                            async execute(a, b) {
+                                throw ('should get here');
+                            }
+                        }(mh.classes.get(this.constructor).key + "/" + key, options ? options.queue : false, options.allowed).run({
+                            args,
+                            fields: await defs.toApiJson()
+                        }));
+                        await defs._updateEntityBasedOnApi(r.fields);
+                        return r.result;
+                    }
+                    catch (e) {
+                        throw defs.catchSaveErrors(e);
+                    }
+                }
+            }
+            else
+                return (await originalMethod.apply(this, args));
+        };
+        registerAction(target.constructor, descriptor);
+        descriptor.value[serverActionField] = serverAction;
+        return descriptor;
+    };
+}
+const customUndefined = {
+    _isUndefined: true
+};
+function registerAction(target, descriptor) {
+    (target[classBackendMethodsArray] || (target[classBackendMethodsArray] = [])).push(descriptor.value);
+    actionInfo.allActions.push(descriptor.value);
+}
+function isCustomUndefined(x) {
+    return x && x._isUndefined;
+}
+export class ProgressListener {
+    constructor(res) {
+        this.res = res;
+    }
+    progress(progress) {
+        this.res.progress(progress);
+    }
+}
+export function prepareArgsToSend(types, args) {
+    if (types) {
+        for (let index = 0; index < types.length; index++) {
+            const paramType = types[index];
+            for (const type of [Remult, SqlDatabase]) {
+                if (args[index] instanceof type)
+                    args[index] = undefined;
+                else if (paramType == type) {
+                    args[index] = undefined;
+                }
+            }
+            if (args[index] != undefined) {
+                let x = { valueType: paramType };
+                x = decorateColumnSettings(x, new Remult());
+                if (x.valueConverter)
+                    args[index] = x.valueConverter.toJson(args[index]);
+                let eo = getEntitySettings(paramType, false);
+                if (eo != null) {
+                    let rh = getEntityRef(args[index]);
+                    args[index] = rh.getId();
+                }
+            }
+        }
+    }
+    return args.map(x => x !== undefined ? x : customUndefined);
+}
+export async function prepareReceivedArgs(types, args, remult, ds, res) {
+    for (let index = 0; index < args.length; index++) {
+        const element = args[index];
+        if (isCustomUndefined(element))
+            args[index] = undefined;
+    }
+    if (types)
+        for (let i = 0; i < types.length; i++) {
+            if (args.length < i) {
+                args.push(undefined);
+            }
+            if (types[i] == Remult || types[i] == Remult) {
+                args[i] = remult;
+            }
+            else if (types[i] == SqlDatabase && ds) {
+                args[i] = ds;
+            }
+            else if (types[i] == ProgressListener) {
+                args[i] = new ProgressListener(res);
+            }
+            else {
+                let x = { valueType: types[i] };
+                x = decorateColumnSettings(x, remult);
+                if (x.valueConverter)
+                    args[i] = x.valueConverter.fromJson(args[i]);
+                let eo = getEntitySettings(types[i], false);
+                if (eo != null) {
+                    if (!(args[i] === null || args[i] === undefined))
+                        args[i] = await remult.repo(types[i]).findId(args[i]);
+                }
+            }
+        }
+    return args;
+}
+export const classBackendMethodsArray = Symbol('classBackendMethodsArray');

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -0,0 +1,23 @@
+import { ClassType } from "../../classType";
+import { Remult } from "../context";
+import { DataProvider } from "../data-interfaces";
+import { Repository } from "../remult3";
+import { CategoriesForTesting } from "../tests/remult-3-entities";
+import { Status } from "../tests/testModel/models";
+export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
+export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature): void;
+export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
+export declare type dbTestWhatSignature = (db: {
+    db: DataProvider;
+    remult: Remult;
+    createEntity<entityType>(entity: ClassType<entityType>): Promise<Repository<entityType>>;
+}) => Promise<void>;
+export declare type dbTestMethodSignature = (key: string, what: dbTestWhatSignature, focus: boolean) => void;
+export declare function testAllDbs<T extends CategoriesForTesting>(key: string, doTest: (helper: {
+    remult: Remult;
+    createData: (doInsert?: (insert: (id: number, name: string, description?: string, status?: Status) => Promise<void>) => Promise<void>, entity?: {
+        new (): CategoriesForTesting;
+    }) => Promise<Repository<T>>;
+    insertFourRows: () => Promise<Repository<T>>;
+}) => Promise<any>, focus?: boolean): Promise<void>;

package/esm/src/shared-tests/db-tests-setup.js

@@ -0,0 +1,66 @@
+import { Remult } from "../context";
+import { InMemoryDataProvider } from "../data-providers/in-memory-database";
+import { Categories } from "../tests/remult-3-entities";
+export function itWithFocus(key, what, focus = false) {
+    if (focus)
+        fit(key, what);
+    else
+        it(key, what);
+}
+export function testAll(key, what, focus = false) {
+    for (const test of databasesTesters) {
+        test(key, what, focus);
+    }
+    loadedTests.push(x => {
+        x(key, what, focus);
+    });
+}
+const databasesTesters = [];
+const loadedTests = [];
+export function addDatabaseToTest(tester) {
+    for (const test of loadedTests) {
+        test(tester);
+    }
+    databasesTesters.push(tester);
+}
+export function testInMemory(key, what, focus = false) {
+    itWithFocus(key + " - in memory", async () => {
+        let remult = new Remult();
+        let db = new InMemoryDataProvider();
+        remult.setDataProvider(db);
+        await what({ db, remult, createEntity: async (x) => remult.repo(x) });
+    }, focus);
+}
+databasesTesters.push(testInMemory);
+export async function testAllDbs(key, doTest, focus = false) {
+    testAll(key, async ({ remult, createEntity }) => {
+        let createData = async (doInsert, entity) => {
+            if (!entity)
+                entity = Categories;
+            let rep = await createEntity(entity);
+            if (doInsert)
+                await doInsert(async (id, name, description, status) => {
+                    let c = rep.create();
+                    c.id = id;
+                    c.categoryName = name;
+                    c.description = description;
+                    if (status)
+                        c.status = status;
+                    await rep.save(c);
+                });
+            return rep;
+        };
+        await doTest({
+            remult,
+            createData,
+            insertFourRows: async () => {
+                return createData(async (i) => {
+                    await i(1, 'noam', 'x');
+                    await i(4, 'yael', 'x');
+                    await i(2, 'yoni', 'y');
+                    await i(3, 'maayan', 'y');
+                });
+            }
+        });
+    }, focus);
+}

package/esm/src/shared-tests/db-tests.db-tests.d.ts

@@ -0,0 +1,26 @@
+import { EntityBase } from "../remult3";
+import { IdEntity } from "../id-entity";
+export declare class stam extends EntityBase {
+    id: number;
+    title: string;
+}
+export declare class tasksWithEnum extends IdEntity {
+    title: string;
+    completed: boolean;
+    priority: Priority;
+}
+export declare enum Priority {
+    Low = 0,
+    High = 1,
+    Critical = 2
+}
+export declare class tasksWithStringEnum extends IdEntity {
+    title: string;
+    completed: boolean;
+    priority: PriorityWithString;
+}
+export declare enum PriorityWithString {
+    Low = "Low",
+    High = "High",
+    Critical = "Critical"
+}