remult 0.14.6 → 0.14.7

package/src/server-action.js

@@ -1,365 +1,599 @@
-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) {
+"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) {
         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.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*/];
+                }
+            });
         });
+    };
+    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;
     }
-}
-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;
+    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;
     }
-    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;
-            }
+    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];
+                }
+            });
         });
-        return result;
-    }
-}
-export const actionInfo = {
+    };
+    return myServerAction;
+}(Action));
+exports.myServerAction = myServerAction;
+exports.actionInfo = {
     allActions: [],
     runningOnServer: false,
-    runActionWithoutBlockingUI: (what) => { return what(); },
-    startBusyWithProgress: () => ({
-        progress: (percent) => { },
-        close: () => { }
-    })
+    runActionWithoutBlockingUI: function (what) { return what(); },
+    startBusyWithProgress: function () { return ({
+        progress: function (percent) { },
+        close: function () { }
+    }); }
 };
-export const serverActionField = Symbol('serverActionField');
-const methodHelpers = new Map();
-const classOptions = new Map();
-export function Controller(key) {
+exports.serverActionField = Symbol('serverActionField');
+var methodHelpers = new Map();
+var classOptions = new Map();
+function Controller(key) {
     return function (target) {
-        let r = target;
-        classOptions.set(r, { key });
-        setControllerSettings(target, { key });
+        var r = target;
+        classOptions.set(r, { key: key });
+        context_1.setControllerSettings(target, { key: key });
         return target;
     };
 }
+exports.Controller = Controller;
 /** 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) => {
+function BackendMethod(options) {
+    return function (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;
+            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];
                 }
-                else
-                    return (await originalMethod.apply(undefined, args));
+                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*/];
+                        }
+                    });
+                });
             };
             registerAction(target, descriptor);
-            descriptor.value[serverActionField] = serverAction;
+            descriptor.value[exports.serverActionField] = serverAction_1;
             return descriptor;
         }
         var types = Reflect.getMetadata("design:paramtypes", target, key);
-        let x = classHelpers.get(target.constructor);
+        var x = context_1.classHelpers.get(target.constructor);
         if (!x) {
-            x = new ClassHelper();
-            classHelpers.set(target.constructor, x);
+            x = new context_1.ClassHelper();
+            context_1.classHelpers.set(target.constructor, x);
         }
-        let mh = new MethodHelper();
+        var mh = new context_1.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);
+        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);
                     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');
+                    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*/];
                             }
-                        }(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;
+                        });
+                    }); });
+                };
+                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);
                     }
                 }
-                else {
-                    let defs = getControllerRef(self, undefined);
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
                     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);
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                     }
+                    finally { if (e_1) throw e_1.error; }
                 }
             }
-            else
-                return (await originalMethod.apply(this, args));
+        };
+        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*/];
+                    }
+                });
+            });
         };
         registerAction(target.constructor, descriptor);
-        descriptor.value[serverActionField] = serverAction;
+        descriptor.value[exports.serverActionField] = serverAction;
         return descriptor;
     };
 }
-const customUndefined = {
+exports.BackendMethod = BackendMethod;
+var customUndefined = {
     _isUndefined: true
 };
 function registerAction(target, descriptor) {
-    (target[classBackendMethodsArray] || (target[classBackendMethodsArray] = [])).push(descriptor.value);
-    actionInfo.allActions.push(descriptor.value);
+    (target[exports.classBackendMethodsArray] || (target[exports.classBackendMethodsArray] = [])).push(descriptor.value);
+    exports.actionInfo.allActions.push(descriptor.value);
 }
 function isCustomUndefined(x) {
     return x && x._isUndefined;
 }
-export class ProgressListener {
-    constructor(res) {
+var ProgressListener = /** @class */ (function () {
+    function ProgressListener(res) {
         this.res = res;
     }
-    progress(progress) {
+    ProgressListener.prototype.progress = function (progress) {
         this.res.progress(progress);
-    }
-}
-export function prepareArgsToSend(types, args) {
+    };
+    return ProgressListener;
+}());
+exports.ProgressListener = ProgressListener;
+function prepareArgsToSend(types, args) {
+    var e_3, _a;
     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;
+        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;
+                    }
                 }
             }
+            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) {
-                let x = { valueType: paramType };
-                x = decorateColumnSettings(x, new Remult());
+                var x = { valueType: paramType };
+                x = remult3_1.decorateColumnSettings(x, new context_1.Remult());
                 if (x.valueConverter)
                     args[index] = x.valueConverter.toJson(args[index]);
-                let eo = getEntitySettings(paramType, false);
+                var eo = remult3_1.getEntitySettings(paramType, false);
                 if (eo != null) {
-                    let rh = getEntityRef(args[index]);
+                    var rh = remult3_1.getEntityRef(args[index]);
                     args[index] = rh.getId();
                 }
             }
         }
     }
-    return args.map(x => x !== undefined ? x : customUndefined);
+    return args.map(function (x) { return 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]);
-                }
+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];
             }
-        }
-    return args;
+        });
+    });
 }
-export const classBackendMethodsArray = Symbol('classBackendMethodsArray');
+exports.prepareReceivedArgs = prepareReceivedArgs;
+exports.classBackendMethodsArray = Symbol('classBackendMethodsArray');