remult 0.14.2 → 0.14.5

package/src/server-action.js

@@ -1,599 +1,365 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.classBackendMethodsArray = exports.prepareReceivedArgs = exports.prepareArgsToSend = exports.ProgressListener = exports.BackendMethod = exports.Controller = exports.serverActionField = exports.actionInfo = exports.myServerAction = exports.Action = void 0;
-var tslib_1 = require("tslib");
-require("reflect-metadata");
-var context_1 = require("./context");
-var sql_database_1 = require("./data-providers/sql-database");
-var remult3_1 = require("./remult3");
-var Action = /** @class */ (function () {
-    function Action(actionUrl, queue, allowed) {
+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;
     }
-    Action.prototype.run = function (pIn) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var r, p, progress_1, runningJob_1;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Action.provider.post(context_1.Remult.apiBaseUrl + '/' + this.actionUrl, pIn)];
-                    case 1:
-                        r = _a.sent();
-                        p = r;
-                        if (!(p && p.queuedJobId)) return [3 /*break*/, 6];
-                        progress_1 = exports.actionInfo.startBusyWithProgress();
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, , 4, 5]);
-                        return [4 /*yield*/, exports.actionInfo.runActionWithoutBlockingUI(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!(!runningJob_1 || !runningJob_1.done)) return [3 /*break*/, 4];
-                                            if (!runningJob_1) return [3 /*break*/, 2];
-                                            return [4 /*yield*/, new Promise(function (res) { return setTimeout(function () {
-                                                    res(undefined);
-                                                }, 200); })];
-                                        case 1:
-                                            _a.sent();
-                                            _a.label = 2;
-                                        case 2: return [4 /*yield*/, Action.provider.post(context_1.Remult.apiBaseUrl + '/' + Action.apiUrlForJobStatus, { queuedJobId: r.queuedJobId })];
-                                        case 3:
-                                            runningJob_1 = _a.sent();
-                                            if (runningJob_1.progress) {
-                                                progress_1.progress(runningJob_1.progress);
-                                            }
-                                            return [3 /*break*/, 0];
-                                        case 4: return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 3:
-                        _a.sent();
-                        if (runningJob_1.error)
-                            throw runningJob_1.error;
-                        progress_1.progress(1);
-                        return [2 /*return*/, runningJob_1.result];
-                    case 4:
-                        progress_1.close();
-                        return [7 /*endfinally*/];
-                    case 5: return [3 /*break*/, 7];
-                    case 6: return [2 /*return*/, r];
-                    case 7: return [2 /*return*/];
-                }
-            });
+    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.prototype.__register = function (reg) {
-        var _this = this;
-        reg(this.actionUrl, this.queue, this.allowed, function (d, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var r, err_1;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.execute(d, req, res)];
-                    case 1:
-                        r = _a.sent();
-                        res.success(r);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        err_1 = _a.sent();
-                        if (err_1 instanceof ForbiddenError)
-                            res.forbidden();
-                        else
-                            res.error(err_1);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        }); });
-    };
-    Action.apiUrlForJobStatus = 'jobStatusInQueue';
-    return Action;
-}());
-exports.Action = Action;
-var ForbiddenError = /** @class */ (function (_super) {
-    tslib_1.__extends(ForbiddenError, _super);
-    function ForbiddenError() {
-        return _super.call(this, "Forbidden") || this;
     }
-    return ForbiddenError;
-}(Error));
-var myServerAction = /** @class */ (function (_super) {
-    tslib_1.__extends(myServerAction, _super);
-    function myServerAction(name, types, options, originalMethod) {
-        var _this = _super.call(this, name, options.queue, options.allowed) || this;
-        _this.types = types;
-        _this.options = options;
-        _this.originalMethod = originalMethod;
-        return _this;
+}
+Action.apiUrlForJobStatus = 'jobStatusInQueue';
+class ForbiddenError extends Error {
+    constructor() {
+        super("Forbidden");
     }
-    myServerAction.prototype.execute = function (info, remult, res) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var result, ds;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        result = { data: {} };
-                        ds = remult._dataSource;
-                        return [4 /*yield*/, ds.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var _a, _b, err_2;
-                                return tslib_1.__generator(this, function (_c) {
-                                    switch (_c.label) {
-                                        case 0:
-                                            remult.setDataProvider(ds);
-                                            if (!remult.isAllowedForInstance(undefined, this.options.allowed))
-                                                throw new ForbiddenError();
-                                            _a = info;
-                                            return [4 /*yield*/, prepareReceivedArgs(this.types, info.args, remult, ds, res)];
-                                        case 1:
-                                            _a.args = _c.sent();
-                                            _c.label = 2;
-                                        case 2:
-                                            _c.trys.push([2, 4, , 5]);
-                                            _b = result;
-                                            return [4 /*yield*/, this.originalMethod(info.args)];
-                                        case 3:
-                                            _b.data = _c.sent();
-                                            return [3 /*break*/, 5];
-                                        case 4:
-                                            err_2 = _c.sent();
-                                            throw err_2;
-                                        case 5: return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, result];
-                }
-            });
+}
+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 myServerAction;
-}(Action));
-exports.myServerAction = myServerAction;
-exports.actionInfo = {
+        return result;
+    }
+}
+export const actionInfo = {
     allActions: [],
     runningOnServer: false,
-    runActionWithoutBlockingUI: function (what) { return what(); },
-    startBusyWithProgress: function () { return ({
-        progress: function (percent) { },
-        close: function () { }
-    }); }
+    runActionWithoutBlockingUI: (what) => { return what(); },
+    startBusyWithProgress: () => ({
+        progress: (percent) => { },
+        close: () => { }
+    })
 };
-exports.serverActionField = Symbol('serverActionField');
-var methodHelpers = new Map();
-var classOptions = new Map();
-function Controller(key) {
+export const serverActionField = Symbol('serverActionField');
+const methodHelpers = new Map();
+const classOptions = new Map();
+export function Controller(key) {
     return function (target) {
-        var r = target;
-        classOptions.set(r, { key: key });
-        context_1.setControllerSettings(target, { key: key });
+        let r = target;
+        classOptions.set(r, { key });
+        setControllerSettings(target, { key });
         return target;
     };
 }
-exports.Controller = Controller;
 /** Indicates that the decorated methods runs on the backend. See: [Backend Methods](https://remult.dev/docs/backendMethods.html) */
-function BackendMethod(options) {
-    return function (target, key, descriptor) {
+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
-            var serverAction_1 = new myServerAction(key, types, options, function (args) { return originalMethod.apply(undefined, args); });
-            descriptor.value = function () {
-                var args = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args[_i] = arguments[_i];
+            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;
                 }
-                return tslib_1.__awaiter(this, void 0, void 0, function () {
-                    var _this = this;
-                    return tslib_1.__generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                if (!!exports.actionInfo.runningOnServer) return [3 /*break*/, 5];
-                                args = prepareArgsToSend(types, args);
-                                if (!(options.blockUser === false)) return [3 /*break*/, 2];
-                                return [4 /*yield*/, exports.actionInfo.runActionWithoutBlockingUI(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                                        switch (_a.label) {
-                                            case 0: return [4 /*yield*/, serverAction_1.run({ args: args })];
-                                            case 1: return [2 /*return*/, (_a.sent()).data];
-                                        }
-                                    }); }); })];
-                            case 1: return [2 /*return*/, _a.sent()];
-                            case 2: return [4 /*yield*/, serverAction_1.run({ args: args })];
-                            case 3: return [2 /*return*/, (_a.sent()).data];
-                            case 4: return [3 /*break*/, 7];
-                            case 5: return [4 /*yield*/, originalMethod.apply(undefined, args)];
-                            case 6: return [2 /*return*/, (_a.sent())];
-                            case 7: return [2 /*return*/];
-                        }
-                    });
-                });
+                else
+                    return (await originalMethod.apply(undefined, args));
             };
             registerAction(target, descriptor);
-            descriptor.value[exports.serverActionField] = serverAction_1;
+            descriptor.value[serverActionField] = serverAction;
             return descriptor;
         }
         var types = Reflect.getMetadata("design:paramtypes", target, key);
-        var x = context_1.classHelpers.get(target.constructor);
+        let x = classHelpers.get(target.constructor);
         if (!x) {
-            x = new context_1.ClassHelper();
-            context_1.classHelpers.set(target.constructor, x);
+            x = new ClassHelper();
+            classHelpers.set(target.constructor, x);
         }
-        var mh = new context_1.MethodHelper();
+        let mh = new MethodHelper();
         methodHelpers.set(descriptor, mh);
         x.methods.push(mh);
         var originalMethod = descriptor.value;
-        var serverAction = {
-            __register: function (reg) {
-                var e_1, _a;
-                var _this = this;
-                var c = new context_1.Remult();
-                var _loop_1 = function (constructor) {
-                    var controllerOptions = mh.classes.get(constructor);
+        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, function (d, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                        var allowed, remult_1, ds, r_1, err_3;
-                        var _this = this;
-                        return tslib_1.__generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    d.args = d.args.map(function (x) { return isCustomUndefined(x) ? undefined : x; });
-                                    allowed = options.allowed;
-                                    _a.label = 1;
-                                case 1:
-                                    _a.trys.push([1, 3, , 4]);
-                                    remult_1 = req;
-                                    ds = remult_1._dataSource;
-                                    return [4 /*yield*/, ds.transaction(function (ds) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                            var _a, repo, y, rowHelper, rows, defs, err_4, y, controllerRef, err_5;
-                                            var _b, _c, _d;
-                                            return tslib_1.__generator(this, function (_e) {
-                                                switch (_e.label) {
-                                                    case 0:
-                                                        remult_1.setDataProvider(ds);
-                                                        _a = d;
-                                                        return [4 /*yield*/, prepareReceivedArgs(types, d.args, remult_1, ds, res)];
-                                                    case 1:
-                                                        _a.args = _e.sent();
-                                                        if (!context_1.allEntities.includes(constructor)) return [3 /*break*/, 13];
-                                                        repo = remult_1.repo(constructor);
-                                                        y = void 0;
-                                                        if (!d.rowInfo.isNewRow) return [3 /*break*/, 3];
-                                                        y = repo.create();
-                                                        rowHelper = repo.getEntityRef(y);
-                                                        return [4 /*yield*/, rowHelper._updateEntityBasedOnApi(d.rowInfo.data)];
-                                                    case 2:
-                                                        _e.sent();
-                                                        return [3 /*break*/, 6];
-                                                    case 3: return [4 /*yield*/, repo.find({
-                                                            where: tslib_1.__assign(tslib_1.__assign({}, repo.metadata.idMetadata.getIdFilter(d.rowInfo.id)), { $and: [repo.metadata.options.apiPrefilter] })
-                                                        })];
-                                                    case 4:
-                                                        rows = _e.sent();
-                                                        if (rows.length != 1)
-                                                            throw new Error("not found or too many matches");
-                                                        y = rows[0];
-                                                        return [4 /*yield*/, repo.getEntityRef(y)._updateEntityBasedOnApi(d.rowInfo.data)];
-                                                    case 5:
-                                                        _e.sent();
-                                                        _e.label = 6;
-                                                    case 6:
-                                                        if (!remult_1.isAllowedForInstance(y, allowed))
-                                                            throw new ForbiddenError();
-                                                        defs = remult3_1.getEntityRef(y);
-                                                        return [4 /*yield*/, defs.__validateEntity()];
-                                                    case 7:
-                                                        _e.sent();
-                                                        _e.label = 8;
-                                                    case 8:
-                                                        _e.trys.push([8, 11, , 12]);
-                                                        _b = {};
-                                                        return [4 /*yield*/, originalMethod.apply(y, d.args)];
-                                                    case 9:
-                                                        _b.result = _e.sent();
-                                                        _c = {};
-                                                        return [4 /*yield*/, defs.toApiJson()];
-                                                    case 10:
-                                                        r_1 = (_b.rowInfo = (_c.data = _e.sent(),
-                                                            _c.isNewRow = defs.isNew(),
-                                                            _c.wasChanged = defs.wasChanged(),
-                                                            _c.id = defs.getOriginalId(),
-                                                            _c),
-                                                            _b);
-                                                        return [3 /*break*/, 12];
-                                                    case 11:
-                                                        err_4 = _e.sent();
-                                                        throw defs.catchSaveErrors(err_4);
-                                                    case 12: return [3 /*break*/, 20];
-                                                    case 13:
-                                                        y = new constructor(remult_1, ds);
-                                                        controllerRef = remult3_1.getControllerRef(y, remult_1);
-                                                        return [4 /*yield*/, controllerRef._updateEntityBasedOnApi(d.fields)];
-                                                    case 14:
-                                                        _e.sent();
-                                                        if (!remult_1.isAllowedForInstance(y, allowed))
-                                                            throw new ForbiddenError();
-                                                        return [4 /*yield*/, controllerRef.__validateEntity()];
-                                                    case 15:
-                                                        _e.sent();
-                                                        _e.label = 16;
-                                                    case 16:
-                                                        _e.trys.push([16, 19, , 20]);
-                                                        _d = {};
-                                                        return [4 /*yield*/, originalMethod.apply(y, d.args)];
-                                                    case 17:
-                                                        _d.result = _e.sent();
-                                                        return [4 /*yield*/, controllerRef.toApiJson()];
-                                                    case 18:
-                                                        r_1 = (_d.fields = _e.sent(),
-                                                            _d);
-                                                        return [3 /*break*/, 20];
-                                                    case 19:
-                                                        err_5 = _e.sent();
-                                                        throw controllerRef.catchSaveErrors(err_5);
-                                                    case 20: return [2 /*return*/];
-                                                }
-                                            });
-                                        }); })];
-                                case 2:
-                                    _a.sent();
-                                    res.success(r_1);
-                                    return [3 /*break*/, 4];
-                                case 3:
-                                    err_3 = _a.sent();
-                                    res.error(err_3);
-                                    return [3 /*break*/, 4];
-                                case 4: return [2 /*return*/];
+                    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');
                             }
-                        });
-                    }); });
-                };
-                try {
-                    for (var _b = tslib_1.__values(mh.classes.keys()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                        var constructor = _c.value;
-                        _loop_1(constructor);
+                        }(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;
                     }
                 }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
+                else {
+                    let defs = getControllerRef(self, undefined);
                     try {
-                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        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);
                     }
-                    finally { if (e_1) throw e_1.error; }
                 }
             }
-        };
-        descriptor.value = function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var self_1, defs, classOptions_1, r, _a, _b, err_6, defs, r, _c, _d, e_2;
-                var _e, _f, _g;
-                return tslib_1.__generator(this, function (_h) {
-                    switch (_h.label) {
-                        case 0:
-                            if (!!exports.actionInfo.runningOnServer) return [3 /*break*/, 16];
-                            self_1 = this;
-                            args = prepareArgsToSend(types, args);
-                            if (!context_1.allEntities.includes(target.constructor)) return [3 /*break*/, 8];
-                            defs = remult3_1.getEntityRef(self_1);
-                            return [4 /*yield*/, defs.__validateEntity()];
-                        case 1:
-                            _h.sent();
-                            classOptions_1 = mh.classes.get(self_1.constructor);
-                            if (!classOptions_1.key) {
-                                classOptions_1.key = defs.repository.metadata.key + "_methods";
-                            }
-                            _h.label = 2;
-                        case 2:
-                            _h.trys.push([2, 6, , 7]);
-                            _b = (_a = new /** @class */ (function (_super) {
-                                tslib_1.__extends(class_1, _super);
-                                function class_1() {
-                                    return _super !== null && _super.apply(this, arguments) || this;
-                                }
-                                class_1.prototype.execute = function (a, b) {
-                                    return tslib_1.__awaiter(this, void 0, void 0, function () {
-                                        return tslib_1.__generator(this, function (_a) {
-                                            throw ('should get here');
-                                        });
-                                    });
-                                };
-                                return class_1;
-                            }(Action))(classOptions_1.key + "/" + key, options ? options.queue : false, options.allowed)).run;
-                            _e = {
-                                args: args
-                            };
-                            _f = {};
-                            return [4 /*yield*/, defs.toApiJson()];
-                        case 3: return [4 /*yield*/, (_b.apply(_a, [(_e.rowInfo = (_f.data = _h.sent(),
-                                    _f.isNewRow = defs.isNew(),
-                                    _f.wasChanged = defs.wasChanged(),
-                                    _f.id = defs.getOriginalId(),
-                                    _f),
-                                    _e)]))];
-                        case 4:
-                            r = _h.sent();
-                            return [4 /*yield*/, defs._updateEntityBasedOnApi(r.rowInfo.data)];
-                        case 5:
-                            _h.sent();
-                            return [2 /*return*/, r.result];
-                        case 6:
-                            err_6 = _h.sent();
-                            defs.catchSaveErrors(err_6);
-                            throw err_6;
-                        case 7: return [3 /*break*/, 15];
-                        case 8:
-                            defs = remult3_1.getControllerRef(self_1, undefined);
-                            _h.label = 9;
-                        case 9:
-                            _h.trys.push([9, 14, , 15]);
-                            return [4 /*yield*/, defs.__validateEntity()];
-                        case 10:
-                            _h.sent();
-                            _d = (_c = new /** @class */ (function (_super) {
-                                tslib_1.__extends(class_2, _super);
-                                function class_2() {
-                                    return _super !== null && _super.apply(this, arguments) || this;
-                                }
-                                class_2.prototype.execute = function (a, b) {
-                                    return tslib_1.__awaiter(this, void 0, void 0, function () {
-                                        return tslib_1.__generator(this, function (_a) {
-                                            throw ('should get here');
-                                        });
-                                    });
-                                };
-                                return class_2;
-                            }(Action))(mh.classes.get(this.constructor).key + "/" + key, options ? options.queue : false, options.allowed)).run;
-                            _g = {
-                                args: args
-                            };
-                            return [4 /*yield*/, defs.toApiJson()];
-                        case 11: return [4 /*yield*/, (_d.apply(_c, [(_g.fields = _h.sent(),
-                                    _g)]))];
-                        case 12:
-                            r = _h.sent();
-                            return [4 /*yield*/, defs._updateEntityBasedOnApi(r.fields)];
-                        case 13:
-                            _h.sent();
-                            return [2 /*return*/, r.result];
-                        case 14:
-                            e_2 = _h.sent();
-                            throw defs.catchSaveErrors(e_2);
-                        case 15: return [3 /*break*/, 18];
-                        case 16: return [4 /*yield*/, originalMethod.apply(this, args)];
-                        case 17: return [2 /*return*/, (_h.sent())];
-                        case 18: return [2 /*return*/];
-                    }
-                });
-            });
+            else
+                return (await originalMethod.apply(this, args));
         };
         registerAction(target.constructor, descriptor);
-        descriptor.value[exports.serverActionField] = serverAction;
+        descriptor.value[serverActionField] = serverAction;
         return descriptor;
     };
 }
-exports.BackendMethod = BackendMethod;
-var customUndefined = {
+const customUndefined = {
     _isUndefined: true
 };
 function registerAction(target, descriptor) {
-    (target[exports.classBackendMethodsArray] || (target[exports.classBackendMethodsArray] = [])).push(descriptor.value);
-    exports.actionInfo.allActions.push(descriptor.value);
+    (target[classBackendMethodsArray] || (target[classBackendMethodsArray] = [])).push(descriptor.value);
+    actionInfo.allActions.push(descriptor.value);
 }
 function isCustomUndefined(x) {
     return x && x._isUndefined;
 }
-var ProgressListener = /** @class */ (function () {
-    function ProgressListener(res) {
+export class ProgressListener {
+    constructor(res) {
         this.res = res;
     }
-    ProgressListener.prototype.progress = function (progress) {
+    progress(progress) {
         this.res.progress(progress);
-    };
-    return ProgressListener;
-}());
-exports.ProgressListener = ProgressListener;
-function prepareArgsToSend(types, args) {
-    var e_3, _a;
+    }
+}
+export function prepareArgsToSend(types, args) {
     if (types) {
-        for (var index = 0; index < types.length; index++) {
-            var paramType = types[index];
-            try {
-                for (var _b = (e_3 = void 0, tslib_1.__values([context_1.Remult, sql_database_1.SqlDatabase])), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var type = _c.value;
-                    if (args[index] instanceof type)
-                        args[index] = undefined;
-                    else if (paramType == type) {
-                        args[index] = undefined;
-                    }
+        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;
                 }
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
             if (args[index] != undefined) {
-                var x = { valueType: paramType };
-                x = remult3_1.decorateColumnSettings(x, new context_1.Remult());
+                let x = { valueType: paramType };
+                x = decorateColumnSettings(x, new Remult());
                 if (x.valueConverter)
                     args[index] = x.valueConverter.toJson(args[index]);
-                var eo = remult3_1.getEntitySettings(paramType, false);
+                let eo = getEntitySettings(paramType, false);
                 if (eo != null) {
-                    var rh = remult3_1.getEntityRef(args[index]);
+                    let rh = getEntityRef(args[index]);
                     args[index] = rh.getId();
                 }
             }
         }
     }
-    return args.map(function (x) { return x !== undefined ? x : customUndefined; });
+    return args.map(x => x !== undefined ? x : customUndefined);
 }
-exports.prepareArgsToSend = prepareArgsToSend;
-function prepareReceivedArgs(types, args, remult, ds, res) {
-    return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var index, element, i, x, eo, _a, _b;
-        return tslib_1.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    for (index = 0; index < args.length; index++) {
-                        element = args[index];
-                        if (isCustomUndefined(element))
-                            args[index] = undefined;
-                    }
-                    if (!types) return [3 /*break*/, 7];
-                    i = 0;
-                    _c.label = 1;
-                case 1:
-                    if (!(i < types.length)) return [3 /*break*/, 7];
-                    if (args.length < i) {
-                        args.push(undefined);
-                    }
-                    if (!(types[i] == context_1.Remult || types[i] == context_1.Remult)) return [3 /*break*/, 2];
-                    args[i] = remult;
-                    return [3 /*break*/, 6];
-                case 2:
-                    if (!(types[i] == sql_database_1.SqlDatabase && ds)) return [3 /*break*/, 3];
-                    args[i] = ds;
-                    return [3 /*break*/, 6];
-                case 3:
-                    if (!(types[i] == ProgressListener)) return [3 /*break*/, 4];
-                    args[i] = new ProgressListener(res);
-                    return [3 /*break*/, 6];
-                case 4:
-                    x = { valueType: types[i] };
-                    x = remult3_1.decorateColumnSettings(x, remult);
-                    if (x.valueConverter)
-                        args[i] = x.valueConverter.fromJson(args[i]);
-                    eo = remult3_1.getEntitySettings(types[i], false);
-                    if (!(eo != null)) return [3 /*break*/, 6];
-                    if (!!(args[i] === null || args[i] === undefined)) return [3 /*break*/, 6];
-                    _a = args;
-                    _b = i;
-                    return [4 /*yield*/, remult.repo(types[i]).findId(args[i])];
-                case 5:
-                    _a[_b] = _c.sent();
-                    _c.label = 6;
-                case 6:
-                    i++;
-                    return [3 /*break*/, 1];
-                case 7: return [2 /*return*/, args];
+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;
 }
-exports.prepareReceivedArgs = prepareReceivedArgs;
-exports.classBackendMethodsArray = Symbol('classBackendMethodsArray');
+export const classBackendMethodsArray = Symbol('classBackendMethodsArray');