remult 0.14.6 → 0.14.7

package/server/expressBridge.js

@@ -1,64 +1,78 @@
-import { __decorate, __metadata } from "tslib";
-import { Remult, IdEntity, Entity, Fields, JsonDataProvider } from '../';
-import { registerActionsOnServer } from './register-actions-on-server';
-import { registerEntitiesOnServer } from './register-entities-on-server';
-import { JsonEntityFileStorage } from './JsonEntityFileStorage';
-import { Action, actionInfo } from '../src/server-action';
-import { DataApi, serializeError } from '../src/data-api';
-import { allEntities } from '../src/context';
-import { getEntityKey } from '../src/remult3';
-export function remultMiddlewareBase(app, options) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.ExpressRequestBridgeToDataApiRequest = exports.SiteArea = exports.remultMiddlewareBase = void 0;
+var tslib_1 = require("tslib");
+var register_actions_on_server_1 = require("./register-actions-on-server");
+var register_entities_on_server_1 = require("./register-entities-on-server");
+var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
+var server_action_1 = require("../src/server-action");
+var data_api_1 = require("../src/data-api");
+var context_1 = require("../src/context");
+var remult3_1 = require("../src/remult3");
+var json_data_provider_1 = require("../src/data-providers/json-data-provider");
+var id_entity_1 = require("../src/id-entity");
+function remultMiddlewareBase(app, options) {
+    var _this = this;
     if (!options) {
         options = {};
     }
-    actionInfo.runningOnServer = true;
+    server_action_1.actionInfo.runningOnServer = true;
     if (options.defaultGetLimit) {
-        DataApi.defaultGetLimit = options.defaultGetLimit;
+        data_api_1.DataApi.defaultGetLimit = options.defaultGetLimit;
     }
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    let dataProvider;
+    var dataProvider;
     if (typeof options.dataProvider === "function") {
         dataProvider = options.dataProvider();
     }
     else
         dataProvider = Promise.resolve(options.dataProvider);
-    dataProvider = dataProvider.then(dp => {
+    dataProvider = dataProvider.then(function (dp) {
         if (dp)
             return dp;
-        return new JsonDataProvider(new JsonEntityFileStorage('./db'));
+        return new json_data_provider_1.JsonDataProvider(new JsonEntityFileStorage_1.JsonEntityFileStorage('./db'));
     });
     if (options.initApi) {
-        dataProvider = dataProvider.then(async (dp) => {
-            var remult = new Remult(dp);
-            await options.initApi(remult);
-            return dp;
-        });
+        dataProvider = dataProvider.then(function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var remult;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        remult = new context_1.Remult(dp);
+                        return [4 /*yield*/, options.initApi(remult)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, dp];
+                }
+            });
+        }); });
     }
-    let bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options.initRequest, dataProvider);
+    var bridge = new ExpressBridge(app, new inProcessQueueHandler(options.queueStorage), options.initRequest, dataProvider);
     if (options.logApiEndPoints !== undefined)
         bridge.logApiEndPoints = options.logApiEndPoints;
     if (options.rootPath === undefined)
-        options.rootPath = Remult.apiBaseUrl;
-    let apiArea = bridge.addArea(options.rootPath);
+        options.rootPath = context_1.Remult.apiBaseUrl;
+    var apiArea = bridge.addArea(options.rootPath);
     if (!options.disableAutoApi) {
-        let actions = [];
+        var actions = [];
         if (options.entities)
-            actions.push(...options.entities);
+            actions.push.apply(actions, tslib_1.__spread(options.entities));
         if (options.controllers)
-            actions.push(...options.controllers);
-        registerActionsOnServer(apiArea, actions);
-        registerEntitiesOnServer(apiArea, options.entities);
+            actions.push.apply(actions, tslib_1.__spread(options.controllers));
+        register_actions_on_server_1.registerActionsOnServer(apiArea, actions);
+        register_entities_on_server_1.registerEntitiesOnServer(apiArea, options.entities);
     }
     return Object.assign(app, {
-        getRemult: (req) => bridge.getRemult(req),
-        openApiDoc: (options) => bridge.openApiDoc(options),
-        addArea: x => bridge.addArea(x)
+        getRemult: function (req) { return bridge.getRemult(req); },
+        openApiDoc: function (options) { return bridge.openApiDoc(options); },
+        addArea: function (x) { return bridge.addArea(x); }
     });
 }
-class ExpressBridge {
-    constructor(app, queue, initRequest, dataProvider) {
+exports.remultMiddlewareBase = remultMiddlewareBase;
+var ExpressBridge = /** @class */ (function () {
+    function ExpressBridge(app, queue, initRequest, dataProvider) {
         this.app = app;
         this.queue = queue;
         this.initRequest = initRequest;
@@ -67,11 +81,12 @@ class ExpressBridge {
         this.backendMethodsOpenApi = [];
         this.logApiEndPoints = true;
     }
-    openApiDoc(options) {
-        let r = new Remult();
+    ExpressBridge.prototype.openApiDoc = function (options) {
+        var e_1, _a, e_2, _b;
+        var r = new context_1.Remult();
         if (!options.version)
             options.version = "1.0.0";
-        let spec = {
+        var spec = {
             info: { title: options.title, version: options.version },
             openapi: "3.0.0",
             //swagger: "2.0",
@@ -87,7 +102,7 @@ class ExpressBridge {
             },
             paths: {}
         };
-        let validationError = {
+        var validationError = {
             "400": {
                 "description": "Error: Bad Request",
                 "content": {
@@ -99,75 +114,86 @@ class ExpressBridge {
                 }
             }
         };
-        let security = {
+        var security = {
             "security": [
                 {
                     "bearerAuth": []
                 }
             ]
         };
-        let secureBase = (condition, def, item) => {
+        var secureBase = function (condition, def, item) {
             if (condition === undefined)
                 condition = def;
             if (condition != false) {
                 if (condition != true) {
-                    item = { ...item, ...security };
+                    item = tslib_1.__assign(tslib_1.__assign({}, item), security);
                     item.responses["403"] = { description: "forbidden" };
                 }
                 return item;
             }
         };
-        for (const e of allEntities) {
-            let meta = r.repo(e).metadata;
-            let key = getEntityKey(e);
-            let parameters = [];
+        var _loop_1 = function (e) {
+            var e_3, _a;
+            var meta = r.repo(e).metadata;
+            var key = remult3_1.getEntityKey(e);
+            var parameters = [];
             if (key) {
-                let properties = {};
-                for (const f of meta.fields) {
-                    let type = f.valueType == String ? "string" :
-                        f.valueType == Boolean ? "boolean" :
-                            f.valueType == Date ? "string" :
-                                f.valueType == Number ? "number" :
-                                    "object";
-                    properties[f.key] = {
-                        type
-                    };
-                    parameters.push({
-                        "name": f.key,
-                        "in": "query",
-                        "description": "filter equal to " + f.key,
-                        "required": false,
-                        "style": "simple",
-                        type
-                    });
-                    parameters.push({
-                        "name": f.key + "_ne",
-                        "in": "query",
-                        "description": "filter not equal to " + f.key,
-                        "required": false,
-                        "style": "simple",
-                        type
-                    });
+                var properties = {};
+                try {
+                    for (var _b = (e_3 = void 0, tslib_1.__values(meta.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var f = _c.value;
+                        var type = f.valueType == String ? "string" :
+                            f.valueType == Boolean ? "boolean" :
+                                f.valueType == Date ? "string" :
+                                    f.valueType == Number ? "number" :
+                                        "object";
+                        properties[f.key] = {
+                            type: type
+                        };
+                        parameters.push({
+                            "name": f.key,
+                            "in": "query",
+                            "description": "filter equal to " + f.key,
+                            "required": false,
+                            "style": "simple",
+                            type: type
+                        });
+                        parameters.push({
+                            "name": f.key + "_ne",
+                            "in": "query",
+                            "description": "filter not equal to " + f.key,
+                            "required": false,
+                            "style": "simple",
+                            type: type
+                        });
+                    }
+                }
+                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; }
                 }
                 spec.components.schemas[key] = {
                     type: "object",
-                    properties
+                    properties: properties
                 };
-                let definition = {
+                var definition = {
                     "$ref": "#/components/schemas/" + key
                 };
-                let secure = (condition, def, item) => {
+                var secure = function (condition, def, item) {
                     item.tags = [meta.key];
                     if (condition === undefined)
                         condition = meta.options.allowApiCrud;
                     return secureBase(condition, def, item);
                 };
-                let apiPath = spec.paths['/api/' + key] = {};
-                let apiPathWithId = spec.paths['/api/' + key + "/{id}"] = {};
+                var apiPath = spec.paths['/api/' + key] = {};
+                var apiPathWithId = spec.paths['/api/' + key + "/{id}"] = {};
                 //https://github.com/2fd/open-api.d.ts
                 apiPath.get = secure(meta.options.allowApiRead, true, {
                     description: "return an array of " + key + ". supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)",
-                    parameters: [{
+                    parameters: tslib_1.__spread([{
                             "name": "_limit",
                             "in": "query",
                             "description": "limit the number of returned rows, default 100",
@@ -195,7 +221,7 @@ class ExpressBridge {
                             "description": "the sort order to user for the columns in `_sort`",
                             "required": false,
                             "schema": { "type": "string" }
-                        }, ...parameters],
+                        }], parameters),
                     responses: {
                         "200": {
                             "description": "returns an array of " + key,
@@ -210,14 +236,14 @@ class ExpressBridge {
                         },
                     }
                 });
-                let idParameter = {
+                var idParameter = {
                     "name": "id",
                     "in": "path",
                     "description": "id of " + key,
                     "required": true,
                     "schema": { "type": "string" },
                 };
-                let itemInBody = {
+                var itemInBody = {
                     "requestBody": {
                         "content": {
                             "application/json": {
@@ -228,13 +254,10 @@ class ExpressBridge {
                         }
                     }
                 };
-                apiPath.post = secure(meta.options.allowApiInsert, false, {
+                apiPath.post = secure(meta.options.allowApiInsert, false, tslib_1.__assign(tslib_1.__assign({ 
                     //"summary": "insert a " + key,
                     //"description": "insert a " + key,
-                    "produces": ["application/json"],
-                    ...itemInBody,
-                    "responses": {
-                        "201": {
+                    "produces": ["application/json"] }, itemInBody), { "responses": tslib_1.__assign({ "201": {
                             "description": "Created",
                             "content": {
                                 "application/json": {
@@ -243,10 +266,7 @@ class ExpressBridge {
                                     }
                                 }
                             }
-                        },
-                        ...validationError
-                    }
-                });
+                        } }, validationError) }));
                 apiPathWithId.get = secure(meta.options.allowApiRead, true, {
                     parameters: [idParameter],
                     responses: {
@@ -262,16 +282,12 @@ class ExpressBridge {
                         },
                     }
                 });
-                apiPathWithId.put = secure(meta.options.allowApiUpdate, false, {
+                apiPathWithId.put = secure(meta.options.allowApiUpdate, false, tslib_1.__assign(tslib_1.__assign({ 
                     //"summary": "Update a " + key,
                     //"description": "Update a " + key,
-                    "produces": ["application/json"],
-                    "parameters": [
+                    "produces": ["application/json"], "parameters": [
                         idParameter
-                    ],
-                    ...itemInBody,
-                    "responses": {
-                        "200": {
+                    ] }, itemInBody), { "responses": tslib_1.__assign({ "200": {
                             "description": "successful operation",
                             "content": {
                                 "application/json": {
@@ -280,10 +296,7 @@ class ExpressBridge {
                                     }
                                 }
                             }
-                        },
-                        ...validationError
-                    }
-                });
+                        } }, validationError) }));
                 apiPathWithId.delete = secure(meta.options.allowApiDelete, false, {
                     //      "summary": "Delete a " + key,
                     //      "description": "Delete a " + key,
@@ -291,55 +304,72 @@ class ExpressBridge {
                     "parameters": [
                         idParameter
                     ],
-                    "responses": {
-                        "204": {
+                    "responses": tslib_1.__assign({ "204": {
                             "description": "Deleted"
-                        },
-                        ...validationError
-                    }
+                        } }, validationError)
                 });
             }
+        };
+        try {
+            for (var allEntities_1 = tslib_1.__values(context_1.allEntities), allEntities_1_1 = allEntities_1.next(); !allEntities_1_1.done; allEntities_1_1 = allEntities_1.next()) {
+                var e = allEntities_1_1.value;
+                _loop_1(e);
+            }
         }
-        for (const b of this.backendMethodsOpenApi) {
-            spec.paths[b.path] = {
-                post: secureBase(b.allowed, false, {
-                    "produces": ["application/json"],
-                    "tags": [b.tag],
-                    "requestBody": {
-                        "content": {
-                            "application/json": {
-                                "schema": {
-                                    "type": "object",
-                                    properties: {
-                                        "args": {
-                                            "type": "array",
-                                            "items": { "type": "string" }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    "responses": {
-                        "201": {
-                            "description": "Created",
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (allEntities_1_1 && !allEntities_1_1.done && (_a = allEntities_1.return)) _a.call(allEntities_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var _c = tslib_1.__values(this.backendMethodsOpenApi), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var b = _d.value;
+                spec.paths[b.path] = {
+                    post: secureBase(b.allowed, false, {
+                        "produces": ["application/json"],
+                        "tags": [b.tag],
+                        "requestBody": {
                             "content": {
                                 "application/json": {
                                     "schema": {
                                         "type": "object",
                                         properties: {
-                                            "data": {
-                                                "type": "object"
+                                            "args": {
+                                                "type": "array",
+                                                "items": { "type": "string" }
                                             }
                                         }
                                     }
                                 }
                             }
                         },
-                        ...validationError
-                    }
-                })
-            };
+                        "responses": tslib_1.__assign({ "201": {
+                                "description": "Created",
+                                "content": {
+                                    "application/json": {
+                                        "schema": {
+                                            "type": "object",
+                                            properties: {
+                                                "data": {
+                                                    "type": "object"
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            } }, validationError)
+                    })
+                };
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
         spec.components.schemas["InvalidResponse"] = {
             "type": "object",
@@ -353,315 +383,472 @@ class ExpressBridge {
             }
         };
         return spec;
-    }
-    addArea(rootUrl) {
+    };
+    ExpressBridge.prototype.addArea = function (rootUrl) {
         var r = new SiteArea(this, this.app, rootUrl, this.logApiEndPoints);
         if (!this.firstArea) {
             this.firstArea = r;
         }
         return r;
-    }
-    async getRemult(req) {
-        return this.firstArea.getRemult(req);
-    }
-}
-export class SiteArea {
-    constructor(bridge, app, rootUrl, logApiEndpoints) {
+    };
+    ExpressBridge.prototype.getRemult = function (req) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.firstArea.getRemult(req)];
+            });
+        });
+    };
+    return ExpressBridge;
+}());
+var SiteArea = /** @class */ (function () {
+    function SiteArea(bridge, app, rootUrl, logApiEndpoints) {
         this.bridge = bridge;
         this.app = app;
         this.rootUrl = rootUrl;
         this.logApiEndpoints = logApiEndpoints;
     }
-    add(key, dataApiFactory) {
-        let myRoute = this.rootUrl + '/' + key;
+    SiteArea.prototype.add = function (key, dataApiFactory) {
+        var _this = this;
+        var myRoute = this.rootUrl + '/' + key;
         if (this.logApiEndpoints)
             console.log(myRoute);
         this.app.route(myRoute)
-            .get(this.process((c, req, res) => dataApiFactory(c).httpGet(res, req))).put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, '', orig.body)))
-            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
-            .post(this.process(async (c, req, res, orig) => dataApiFactory(c).httpPost(res, req, orig.body)));
+            .get(this.process(function (c, req, res) {
+            return dataApiFactory(c).httpGet(res, req);
+        })).put(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).put(res, '', orig.body)];
+        }); }); }))
+            .delete(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).delete(res, '')];
+        }); }); }))
+            .post(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).httpPost(res, req, orig.body)];
+        }); }); }));
         this.app.route(myRoute + '/:id')
             //@ts-ignore
-            .get(this.process(async (c, req, res, orig) => dataApiFactory(c).get(res, orig.params.id)))
+            .get(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).get(res, orig.params.id)];
+        }); }); }))
             //@ts-ignore
-            .put(this.process(async (c, req, res, orig) => dataApiFactory(c).put(res, orig.params.id, orig.body)))
+            .put(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).put(res, orig.params.id, orig.body)];
+        }); }); }))
             //@ts-ignore
-            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, orig.params.id)));
-    }
-    process(what) {
-        return async (req, res) => {
-            let myReq = new ExpressRequestBridgeToDataApiRequest(req);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
-            let remult = new Remult();
-            remult.setDataProvider(await this.bridge.dataProvider);
-            if (req) {
-                let user = req['user'];
-                if (!user)
-                    user = req['auth'];
-                if (user)
-                    remult.setUser(user);
-            }
-            if (this.bridge.initRequest) {
-                await this.bridge.initRequest(remult, req);
-            }
-            what(remult, myReq, myRes, req);
-        };
-    }
+            .delete(this.process(function (c, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, dataApiFactory(c).delete(res, orig.params.id)];
+        }); }); }));
+    };
+    SiteArea.prototype.process = function (what) {
+        var _this = this;
+        return function (req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var myReq, myRes, remult, _a, _b, user;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        myReq = new ExpressRequestBridgeToDataApiRequest(req);
+                        myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
+                        remult = new context_1.Remult();
+                        _b = (_a = remult).setDataProvider;
+                        return [4 /*yield*/, this.bridge.dataProvider];
+                    case 1:
+                        _b.apply(_a, [_c.sent()]);
+                        if (req) {
+                            user = req['user'];
+                            if (!user)
+                                user = req['auth'];
+                            if (user)
+                                remult.setUser(user);
+                        }
+                        if (!this.bridge.initRequest) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.bridge.initRequest(remult, req)];
+                    case 2:
+                        _c.sent();
+                        _c.label = 3;
+                    case 3:
+                        what(remult, myReq, myRes, req);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+    };
     ;
-    async getRemult(req) {
-        let remult;
-        await this.process(async (c) => {
-            remult = c;
-        })(req, undefined);
-        return remult;
-    }
-    initQueue() {
+    SiteArea.prototype.getRemult = function (req) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var remult;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.process(function (c) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                remult = c;
+                                return [2 /*return*/];
+                            });
+                        }); })(req, undefined)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, remult];
+                }
+            });
+        });
+    };
+    SiteArea.prototype.initQueue = function () {
+        var _this = this;
         this.addAction({
-            __register: x => {
-                x(Action.apiUrlForJobStatus, false, () => true, async (data, req, res) => {
-                    let job = await this.bridge.queue.getJobInfo(data.queuedJobId);
-                    let userId = undefined;
-                    if (req?.user)
-                        userId = req.user.id;
-                    if (job.userId == '')
-                        job.userId = undefined;
-                    if (userId != job.userId)
-                        res.forbidden();
-                    else
-                        res.success(job.info);
-                });
+            __register: function (x) {
+                x(server_action_1.Action.apiUrlForJobStatus, false, function () { return true; }, function (data, req, res) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var job, userId;
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, this.bridge.queue.getJobInfo(data.queuedJobId)];
+                            case 1:
+                                job = _a.sent();
+                                userId = undefined;
+                                if (req === null || req === void 0 ? void 0 : req.user)
+                                    userId = req.user.id;
+                                if (job.userId == '')
+                                    job.userId = undefined;
+                                if (userId != job.userId)
+                                    res.forbidden();
+                                else
+                                    res.success(job.info);
+                                return [2 /*return*/];
+                        }
+                    });
+                }); });
             }
         });
-        this.initQueue = () => { };
-    }
-    addAction(action) {
-        action.__register((url, queue, allowed, what) => {
-            let myUrl = this.rootUrl + '/' + url;
-            let tag = (() => {
-                let split = url.split('/');
+        this.initQueue = function () { };
+    };
+    SiteArea.prototype.addAction = function (action) {
+        var _this = this;
+        action.__register(function (url, queue, allowed, what) {
+            var myUrl = _this.rootUrl + '/' + url;
+            var tag = (function () {
+                var split = url.split('/');
                 if (split.length == 1)
                     return 'Static Backend Methods';
                 else
                     return split[0];
             })();
-            this.bridge.backendMethodsOpenApi.push({ path: myUrl, allowed, tag });
-            if (this.logApiEndpoints)
+            _this.bridge.backendMethodsOpenApi.push({ path: myUrl, allowed: allowed, tag: tag });
+            if (_this.logApiEndpoints)
                 console.log(myUrl);
             if (queue) {
-                this.initQueue();
-                this.bridge.queue.mapQueuedAction(myUrl, what);
+                _this.initQueue();
+                _this.bridge.queue.mapQueuedAction(myUrl, what);
             }
-            this.app.route(myUrl).post(this.process(async (remult, req, res, orig) => {
-                if (queue) {
-                    let r = {
-                        queuedJobId: await this.bridge.queue.submitJob(myUrl, remult, orig.body)
-                    };
-                    res.success(r);
-                }
-                else
-                    return what(orig.body, remult, res);
-            }));
+            _this.app.route(myUrl).post(_this.process(function (remult, req, res, orig) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var r;
+                var _a;
+                return tslib_1.__generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!queue) return [3 /*break*/, 2];
+                            _a = {};
+                            return [4 /*yield*/, this.bridge.queue.submitJob(myUrl, remult, orig.body)];
+                        case 1:
+                            r = (_a.queuedJobId = _b.sent(),
+                                _a);
+                            res.success(r);
+                            return [3 /*break*/, 3];
+                        case 2: return [2 /*return*/, what(orig.body, remult, res)];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); }));
         });
-    }
-}
-export class ExpressRequestBridgeToDataApiRequest {
-    constructor(r) {
+    };
+    return SiteArea;
+}());
+exports.SiteArea = SiteArea;
+var ExpressRequestBridgeToDataApiRequest = /** @class */ (function () {
+    function ExpressRequestBridgeToDataApiRequest(r) {
         this.r = r;
     }
-    get(key) {
+    ExpressRequestBridgeToDataApiRequest.prototype.get = function (key) {
         return this.r.query[key];
-    }
-}
-class ExpressResponseBridgeToDataApiResponse {
-    constructor(r, req) {
+    };
+    return ExpressRequestBridgeToDataApiRequest;
+}());
+exports.ExpressRequestBridgeToDataApiRequest = ExpressRequestBridgeToDataApiRequest;
+var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
+    function ExpressResponseBridgeToDataApiResponse(r, req) {
         this.r = r;
         this.req = req;
     }
-    forbidden() {
+    ExpressResponseBridgeToDataApiResponse.prototype.forbidden = function () {
         this.sendStatus(403);
-    }
-    sendStatus(status) {
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.sendStatus = function (status) {
         this.r.writeHead(status).end();
-    }
-    progress(progress) {
-    }
-    success(data) {
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.progress = function (progress) {
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.success = function (data) {
         this.r.json(data);
-    }
-    created(data) {
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.created = function (data) {
         this.r.statusCode = 201;
         this.r.json(data);
-    }
-    deleted() {
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.deleted = function () {
         this.sendStatus(204);
-    }
-    notFound() {
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.notFound = function () {
         this.sendStatus(404);
-    }
-    error(data) {
-        data = serializeError(data);
+    };
+    ExpressResponseBridgeToDataApiResponse.prototype.error = function (data) {
+        var _a, _b;
+        data = data_api_1.serializeError(data);
         console.error({
             message: data.message,
-            stack: data.stack?.split('\n'),
-            url: this.req.originalUrl ?? this.req.path,
+            stack: (_a = data.stack) === null || _a === void 0 ? void 0 : _a.split('\n'),
+            url: (_b = this.req.originalUrl) !== null && _b !== void 0 ? _b : this.req.path,
             method: this.req.method
         });
         this.r.status(400).json(data);
-    }
-}
+    };
+    return ExpressResponseBridgeToDataApiResponse;
+}());
 function throwError() {
     throw "Invalid";
 }
-class inProcessQueueHandler {
-    constructor(storage) {
+var inProcessQueueHandler = /** @class */ (function () {
+    function inProcessQueueHandler(storage) {
         this.storage = storage;
         this.actions = new Map();
     }
-    async submitJob(url, req, body) {
-        let id = await this.storage.createJob(url, req.user ? req.user.id : undefined);
-        let job = await this.storage.getJobInfo(id);
-        this.actions.get(url)(body, req, {
-            error: error => job.setErrorResult(serializeError(error)),
-            success: result => job.setResult(result),
-            progress: progress => job.setProgress(progress)
+    inProcessQueueHandler.prototype.submitJob = function (url, req, body) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var id, job;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.storage.createJob(url, req.user ? req.user.id : undefined)];
+                    case 1:
+                        id = _a.sent();
+                        return [4 /*yield*/, this.storage.getJobInfo(id)];
+                    case 2:
+                        job = _a.sent();
+                        this.actions.get(url)(body, req, {
+                            error: function (error) { return job.setErrorResult(data_api_1.serializeError(error)); },
+                            success: function (result) { return job.setResult(result); },
+                            progress: function (progress) { return job.setProgress(progress); }
+                        });
+                        return [2 /*return*/, id];
+                }
+            });
         });
-        return id;
-    }
-    mapQueuedAction(url, what) {
+    };
+    inProcessQueueHandler.prototype.mapQueuedAction = function (url, what) {
         this.actions.set(url, what);
-    }
-    async getJobInfo(queuedJobId) {
-        return await this.storage.getJobInfo(queuedJobId);
-    }
-}
-class InMemoryQueueStorage {
-    constructor() {
+    };
+    inProcessQueueHandler.prototype.getJobInfo = function (queuedJobId) {
+        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*/, this.storage.getJobInfo(queuedJobId)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    return inProcessQueueHandler;
+}());
+var InMemoryQueueStorage = /** @class */ (function () {
+    function InMemoryQueueStorage() {
         this.jobs = new Map();
     }
-    async getJobInfo(queuedJobId) {
-        return this.jobs.get(queuedJobId);
-    }
-    async createJob(url, userId) {
-        let id = this.jobs.size.toString();
-        this.jobs.set(id, {
-            info: {
-                done: false
-            },
-            userId: userId,
-            setErrorResult: (error) => {
-                let job = this.jobs.get(id);
-                job.info.done = true;
-                job.info.error = error;
-            },
-            setResult: (result) => {
-                let job = this.jobs.get(id);
-                job.info.done = true;
-                job.info.result = result;
-            },
-            setProgress: (progress) => {
-                let job = this.jobs.get(id);
-                job.info.progress = progress;
-            }
+    InMemoryQueueStorage.prototype.getJobInfo = function (queuedJobId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.jobs.get(queuedJobId)];
+            });
         });
-        return id;
-    }
-}
-let test = 0;
-export class EntityQueueStorage {
-    constructor(repo) {
+    };
+    InMemoryQueueStorage.prototype.createJob = function (url, userId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var id;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                id = this.jobs.size.toString();
+                this.jobs.set(id, {
+                    info: {
+                        done: false
+                    },
+                    userId: userId,
+                    setErrorResult: function (error) {
+                        var job = _this.jobs.get(id);
+                        job.info.done = true;
+                        job.info.error = error;
+                    },
+                    setResult: function (result) {
+                        var job = _this.jobs.get(id);
+                        job.info.done = true;
+                        job.info.result = result;
+                    },
+                    setProgress: function (progress) {
+                        var job = _this.jobs.get(id);
+                        job.info.progress = progress;
+                    }
+                });
+                return [2 /*return*/, id];
+            });
+        });
+    };
+    return InMemoryQueueStorage;
+}());
+var test = 0;
+var EntityQueueStorage = /** @class */ (function () {
+    function EntityQueueStorage(repo) {
         this.repo = repo;
         this.sync = Promise.resolve();
     }
-    doSync(what) {
-        return this.sync = this.sync.then(() => what());
-    }
-    async getJobInfo(queuedJobId) {
-        let q = await this.repo.findId(queuedJobId);
-        let lastProgress = undefined;
-        return {
-            userId: q.userId,
-            info: {
-                done: q.done,
-                error: q.error ? JSON.parse(q.result) : undefined,
-                result: q.done && !q.error ? JSON.parse(q.result) : undefined,
-                progress: q.progress
-            },
-            setErrorResult: async (error) => {
-                await this.sync;
-                q.error = true;
-                q.done = true;
-                q.result = JSON.stringify(error);
-                q.doneTime = new Date();
-                q.progress = 1;
-                await this.doSync(() => q._.save());
-            },
-            setResult: async (result) => {
-                await this.sync;
-                q.done = true;
-                q.result = JSON.stringify(result);
-                q.doneTime = new Date();
-                await this.doSync(() => q._.save());
-            },
-            setProgress: async (progress) => {
-                if (progress === 0)
-                    return;
-                let now = new Date();
-                if (lastProgress && now.valueOf() - lastProgress.valueOf() < 200)
-                    return;
-                lastProgress = new Date();
-                await this.sync;
-                q.progress = progress;
-                await this.doSync(() => q._.save());
-            }
-        };
-    }
-    async createJob(url, userId) {
-        let q = this.repo.create();
-        q.userId = userId;
-        q.submitTime = new Date();
-        q.url = url;
-        await q._.save();
-        return q.id;
-    }
-}
-let JobsInQueueEntity = class JobsInQueueEntity extends IdEntity {
-};
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], JobsInQueueEntity.prototype, "userId", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], JobsInQueueEntity.prototype, "url", void 0);
-__decorate([
-    Fields.date(),
-    __metadata("design:type", Date)
-], JobsInQueueEntity.prototype, "submitTime", void 0);
-__decorate([
-    Fields.date(),
-    __metadata("design:type", Date)
-], JobsInQueueEntity.prototype, "doneTime", void 0);
-__decorate([
-    Fields.string(),
-    __metadata("design:type", String)
-], JobsInQueueEntity.prototype, "result", void 0);
-__decorate([
-    Fields.boolean(),
-    __metadata("design:type", Boolean)
-], JobsInQueueEntity.prototype, "done", void 0);
-__decorate([
-    Fields.boolean(),
-    __metadata("design:type", Boolean)
-], JobsInQueueEntity.prototype, "error", void 0);
-__decorate([
-    Fields.number(),
-    __metadata("design:type", Number)
-], JobsInQueueEntity.prototype, "progress", void 0);
-JobsInQueueEntity = __decorate([
-    Entity(undefined, {
-        dbName: 'jobsInQueue'
-    })
-], JobsInQueueEntity);
-export { JobsInQueueEntity };
-allEntities.splice(allEntities.indexOf(JobsInQueueEntity), 1);
+    EntityQueueStorage.prototype.doSync = function (what) {
+        return this.sync = this.sync.then(function () { return what(); });
+    };
+    EntityQueueStorage.prototype.getJobInfo = function (queuedJobId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var q, lastProgress;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repo.findId(queuedJobId)];
+                    case 1:
+                        q = _a.sent();
+                        lastProgress = undefined;
+                        return [2 /*return*/, {
+                                userId: q.userId,
+                                info: {
+                                    done: q.done,
+                                    error: q.error ? JSON.parse(q.result) : undefined,
+                                    result: q.done && !q.error ? JSON.parse(q.result) : undefined,
+                                    progress: q.progress
+                                },
+                                setErrorResult: function (error) { 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*/, this.sync];
+                                            case 1:
+                                                _a.sent();
+                                                q.error = true;
+                                                q.done = true;
+                                                q.result = JSON.stringify(error);
+                                                q.doneTime = new Date();
+                                                q.progress = 1;
+                                                return [4 /*yield*/, this.doSync(function () { return q._.save(); })];
+                                            case 2:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); },
+                                setResult: function (result) { 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*/, this.sync];
+                                            case 1:
+                                                _a.sent();
+                                                q.done = true;
+                                                q.result = JSON.stringify(result);
+                                                q.doneTime = new Date();
+                                                return [4 /*yield*/, this.doSync(function () { return q._.save(); })];
+                                            case 2:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); },
+                                setProgress: function (progress) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                    var now;
+                                    return tslib_1.__generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (progress === 0)
+                                                    return [2 /*return*/];
+                                                now = new Date();
+                                                if (lastProgress && now.valueOf() - lastProgress.valueOf() < 200)
+                                                    return [2 /*return*/];
+                                                lastProgress = new Date();
+                                                return [4 /*yield*/, this.sync];
+                                            case 1:
+                                                _a.sent();
+                                                q.progress = progress;
+                                                return [4 /*yield*/, this.doSync(function () { return q._.save(); })];
+                                            case 2:
+                                                _a.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); }
+                            }];
+                }
+            });
+        });
+    };
+    EntityQueueStorage.prototype.createJob = function (url, userId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var q;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        q = this.repo.create();
+                        q.userId = userId;
+                        q.submitTime = new Date();
+                        q.url = url;
+                        return [4 /*yield*/, q._.save()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, q.id];
+                }
+            });
+        });
+    };
+    return EntityQueueStorage;
+}());
+exports.EntityQueueStorage = EntityQueueStorage;
+var JobsInQueueEntity = /** @class */ (function (_super) {
+    tslib_1.__extends(JobsInQueueEntity, _super);
+    function JobsInQueueEntity() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], JobsInQueueEntity.prototype, "userId", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], JobsInQueueEntity.prototype, "url", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.date(),
+        tslib_1.__metadata("design:type", Date)
+    ], JobsInQueueEntity.prototype, "submitTime", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.date(),
+        tslib_1.__metadata("design:type", Date)
+    ], JobsInQueueEntity.prototype, "doneTime", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string(),
+        tslib_1.__metadata("design:type", String)
+    ], JobsInQueueEntity.prototype, "result", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], JobsInQueueEntity.prototype, "done", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Boolean)
+    ], JobsInQueueEntity.prototype, "error", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.number(),
+        tslib_1.__metadata("design:type", Number)
+    ], JobsInQueueEntity.prototype, "progress", void 0);
+    JobsInQueueEntity = tslib_1.__decorate([
+        remult3_1.Entity(undefined, {
+            dbName: 'jobsInQueue'
+        })
+    ], JobsInQueueEntity);
+    return JobsInQueueEntity;
+}(id_entity_1.IdEntity));
+exports.JobsInQueueEntity = JobsInQueueEntity;
+context_1.allEntities.splice(context_1.allEntities.indexOf(JobsInQueueEntity), 1);