remult 0.14.2 → 0.14.5

package/src/data-api.js

@@ -1,22 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeError = exports.determineSort = exports.DataApi = void 0;
-var tslib_1 = require("tslib");
-var filter_interfaces_1 = require("./filter/filter-interfaces");
-var filter_interfaces_2 = require("./filter/filter-interfaces");
-var DataApi = /** @class */ (function () {
-    function DataApi(repository, remult) {
+import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
+import { Filter } from './filter/filter-interfaces';
+export class DataApi {
+    constructor(repository, remult) {
         this.repository = repository;
         this.remult = remult;
     }
-    DataApi.prototype.httpGet = function (res, req) {
+    httpGet(res, req) {
         if (req.get("__action") == "count") {
             return this.count(res, req);
         }
         else
             return this.getArray(res, req);
-    };
-    DataApi.prototype.httpPost = function (res, req, body) {
+    }
+    httpPost(res, req, body) {
         switch (req.get("__action")) {
             case "get":
                 return this.getArray(res, req, body);
@@ -25,327 +21,169 @@ var DataApi = /** @class */ (function () {
             default:
                 return this.post(res, body);
         }
-    };
-    DataApi.prototype.get = function (response, id) {
-        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 (!this.repository.metadata.apiReadAllowed) {
-                            response.forbidden();
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.doOnId(response, id, function (row) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                                return [2 /*return*/, response.success(this.repository.getEntityRef(row).toApiJson())];
-                            }); }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    DataApi.prototype.count = function (response, request, filterBody) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _a, _b, _c, _d, err_1;
-            var _e;
-            return tslib_1.__generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        if (!this.repository.metadata.apiReadAllowed) {
-                            response.forbidden();
-                            return [2 /*return*/];
-                        }
-                        _f.label = 1;
-                    case 1:
-                        _f.trys.push([1, 4, , 5]);
-                        _b = (_a = response).success;
-                        _e = {};
-                        _d = (_c = this.repository).count;
-                        return [4 /*yield*/, this.buildWhere(request, filterBody)];
-                    case 2: return [4 /*yield*/, _d.apply(_c, [_f.sent()])];
-                    case 3:
-                        _b.apply(_a, [(_e.count = +(_f.sent()), _e)]);
-                        return [3 /*break*/, 5];
-                    case 4:
-                        err_1 = _f.sent();
-                        response.error(err_1);
-                        return [3 /*break*/, 5];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    DataApi.prototype.getArray = function (response, request, filterBody) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var findOptions, _a, hasId_1, w, sort, dir, limit, err_2;
-            var _this = this;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!this.repository.metadata.apiReadAllowed) {
-                            response.forbidden();
-                            return [2 /*return*/];
-                        }
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 6, , 7]);
-                        findOptions = { load: function () { return []; } };
-                        _a = findOptions;
-                        return [4 /*yield*/, this.buildWhere(request, filterBody)];
-                    case 2:
-                        _a.where = _b.sent();
-                        if (!this.remult.isAllowed(this.repository.metadata.options.apiRequireId)) return [3 /*break*/, 4];
-                        hasId_1 = false;
-                        return [4 /*yield*/, filter_interfaces_2.Filter.fromEntityFilter(this.repository.metadata, findOptions.where)];
-                    case 3:
-                        w = _b.sent();
-                        if (w) {
-                            w.__applyToConsumer({
-                                containsCaseInsensitive: function () { },
-                                isDifferentFrom: function () { },
-                                isEqualTo: function (col, val) {
-                                    if (_this.repository.metadata.idMetadata.isIdField(col))
-                                        hasId_1 = true;
-                                },
-                                custom: function () { },
-                                databaseCustom: function () { },
-                                isGreaterOrEqualTo: function () { },
-                                isGreaterThan: function () { },
-                                isIn: function () { },
-                                isLessOrEqualTo: function () { },
-                                isLessThan: function () { },
-                                isNotNull: function () { },
-                                isNull: function () { },
-                                or: function () { }
-                            });
-                        }
-                        if (!hasId_1) {
-                            response.forbidden();
-                            return [2 /*return*/];
-                        }
-                        _b.label = 4;
-                    case 4:
-                        if (request) {
-                            sort = request.get("_sort");
-                            if (sort != undefined) {
-                                dir = request.get('_order');
-                                findOptions.orderBy = determineSort(sort, dir);
-                            }
-                            limit = +request.get("_limit");
-                            if (!limit && DataApi.defaultGetLimit)
-                                limit = DataApi.defaultGetLimit;
-                            findOptions.limit = limit;
-                            findOptions.page = +request.get("_page");
-                        }
-                        return [4 /*yield*/, this.repository.find(findOptions)
-                                .then(function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var _a, _b;
-                                var _this = this;
-                                return tslib_1.__generator(this, function (_c) {
-                                    switch (_c.label) {
-                                        case 0:
-                                            _b = (_a = response).success;
-                                            return [4 /*yield*/, Promise.all(r.map(function (y) { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                                                    return [2 /*return*/, this.repository.getEntityRef(y).toApiJson()];
-                                                }); }); }))];
-                                        case 1:
-                                            _b.apply(_a, [_c.sent()]);
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 5:
-                        _b.sent();
-                        return [3 /*break*/, 7];
-                    case 6:
-                        err_2 = _b.sent();
-                        response.error(err_2);
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    DataApi.prototype.buildWhere = function (request, filterBody) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var where, _a, _b;
-            return tslib_1.__generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        where = [];
-                        if (!this.repository.metadata.options.apiPrefilter) return [3 /*break*/, 3];
-                        if (!(typeof this.repository.metadata.options.apiPrefilter === "function")) return [3 /*break*/, 2];
-                        _b = (_a = where).push;
-                        return [4 /*yield*/, this.repository.metadata.options.apiPrefilter()];
-                    case 1:
-                        _b.apply(_a, [_c.sent()]);
-                        return [3 /*break*/, 3];
-                    case 2:
-                        where.push(this.repository.metadata.options.apiPrefilter);
-                        _c.label = 3;
-                    case 3:
-                        if (request) {
-                            where.push(filter_interfaces_1.buildFilterFromRequestParameters(this.repository.metadata, {
-                                get: function (key) {
-                                    var result = request.get(key);
-                                    if (key.startsWith(filter_interfaces_1.customUrlToken) && result)
-                                        return JSON.parse(result);
-                                    return result;
-                                }
-                            }));
-                        }
-                        if (filterBody)
-                            where.push(filter_interfaces_2.Filter.entityFilterFromJson(this.repository.metadata, filterBody));
-                        return [2 /*return*/, { $and: where }];
+    }
+    async get(response, id) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        await this.doOnId(response, id, async (row) => response.success(this.repository.getEntityRef(row).toApiJson()));
+    }
+    async count(response, request, filterBody) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            response.success({ count: +await this.repository.count(await this.buildWhere(request, filterBody)) });
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+    async getArray(response, request, filterBody) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            let findOptions = { load: () => [] };
+            findOptions.where = await this.buildWhere(request, filterBody);
+            if (this.remult.isAllowed(this.repository.metadata.options.apiRequireId)) {
+                let hasId = false;
+                let w = await Filter.fromEntityFilter(this.repository.metadata, findOptions.where);
+                if (w) {
+                    w.__applyToConsumer({
+                        containsCaseInsensitive: () => { },
+                        isDifferentFrom: () => { },
+                        isEqualTo: (col, val) => {
+                            if (this.repository.metadata.idMetadata.isIdField(col))
+                                hasId = true;
+                        },
+                        custom: () => { },
+                        databaseCustom: () => { },
+                        isGreaterOrEqualTo: () => { },
+                        isGreaterThan: () => { },
+                        isIn: () => { },
+                        isLessOrEqualTo: () => { },
+                        isLessThan: () => { },
+                        isNotNull: () => { },
+                        isNull: () => { },
+                        or: () => { }
+                    });
                 }
-            });
-        });
-    };
-    DataApi.prototype.doOnId = function (response, id, what) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var err_3;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.repository.find({
-                                where: { $and: [this.repository.metadata.options.apiPrefilter, this.repository.metadata.idMetadata.getIdFilter(id)] }
-                            })
-                                .then(function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!(r.length == 0)) return [3 /*break*/, 1];
-                                            response.notFound();
-                                            return [3 /*break*/, 4];
-                                        case 1:
-                                            if (!(r.length > 1)) return [3 /*break*/, 2];
-                                            response.error({ message: "id is not unique" });
-                                            return [3 /*break*/, 4];
-                                        case 2: return [4 /*yield*/, what(r[0])];
-                                        case 3:
-                                            _a.sent();
-                                            _a.label = 4;
-                                        case 4: return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 1:
-                        _a.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        err_3 = _a.sent();
-                        response.error(err_3);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+                if (!hasId) {
+                    response.forbidden();
+                    return;
                 }
-            });
-        });
-    };
-    DataApi.prototype.put = function (response, id, body) {
-        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: return [4 /*yield*/, this.doOnId(response, id, function (row) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var ref;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        ref = this.repository.getEntityRef(row);
-                                        return [4 /*yield*/, ref._updateEntityBasedOnApi(body)];
-                                    case 1:
-                                        _a.sent();
-                                        if (!ref.apiUpdateAllowed) {
-                                            response.forbidden();
-                                            return [2 /*return*/];
-                                        }
-                                        return [4 /*yield*/, this.repository.getEntityRef(row).save()];
-                                    case 2:
-                                        _a.sent();
-                                        response.success(this.repository.getEntityRef(row).toApiJson());
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+            }
+            if (request) {
+                let sort = request.get("_sort");
+                if (sort != undefined) {
+                    let dir = request.get('_order');
+                    findOptions.orderBy = determineSort(sort, dir);
                 }
+                let limit = +request.get("_limit");
+                if (!limit && DataApi.defaultGetLimit)
+                    limit = DataApi.defaultGetLimit;
+                findOptions.limit = limit;
+                findOptions.page = +request.get("_page");
+            }
+            await this.repository.find(findOptions)
+                .then(async (r) => {
+                response.success(await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson())));
             });
-        });
-    };
-    DataApi.prototype.delete = function (response, id) {
-        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: return [4 /*yield*/, this.doOnId(response, id, function (row) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!this.repository.getEntityRef(row).apiDeleteAllowed) {
-                                            response.forbidden();
-                                            return [2 /*return*/];
-                                        }
-                                        return [4 /*yield*/, this.repository.getEntityRef(row).delete()];
-                                    case 1:
-                                        _a.sent();
-                                        response.deleted();
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+    async buildWhere(request, filterBody) {
+        var where = [];
+        if (this.repository.metadata.options.apiPrefilter) {
+            if (typeof this.repository.metadata.options.apiPrefilter === "function")
+                where.push(await this.repository.metadata.options.apiPrefilter());
+            else
+                where.push(this.repository.metadata.options.apiPrefilter);
+        }
+        if (request) {
+            where.push(buildFilterFromRequestParameters(this.repository.metadata, {
+                get: key => {
+                    let result = request.get(key);
+                    if (key.startsWith(customUrlToken) && result)
+                        return JSON.parse(result);
+                    return result;
                 }
+            }));
+        }
+        if (filterBody)
+            where.push(Filter.entityFilterFromJson(this.repository.metadata, filterBody));
+        return { $and: where };
+    }
+    async doOnId(response, id, what) {
+        try {
+            await this.repository.find({
+                where: { $and: [this.repository.metadata.options.apiPrefilter, this.repository.metadata.idMetadata.getIdFilter(id)] }
+            })
+                .then(async (r) => {
+                if (r.length == 0)
+                    response.notFound();
+                else if (r.length > 1)
+                    response.error({ message: "id is not unique" });
+                else
+                    await what(r[0]);
             });
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+    async put(response, id, body) {
+        await this.doOnId(response, id, async (row) => {
+            let ref = this.repository.getEntityRef(row);
+            await ref._updateEntityBasedOnApi(body);
+            if (!ref.apiUpdateAllowed) {
+                response.forbidden();
+                return;
+            }
+            await this.repository.getEntityRef(row).save();
+            response.success(this.repository.getEntityRef(row).toApiJson());
         });
-    };
-    DataApi.prototype.post = function (response, body) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var newr, err_4;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        newr = this.repository.create();
-                        return [4 /*yield*/, this.repository.getEntityRef(newr)._updateEntityBasedOnApi(body)];
-                    case 1:
-                        _a.sent();
-                        if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
-                            response.forbidden();
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.repository.getEntityRef(newr).save()];
-                    case 2:
-                        _a.sent();
-                        response.created(this.repository.getEntityRef(newr).toApiJson());
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_4 = _a.sent();
-                        response.error(err_4);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
-                }
-            });
+    }
+    async delete(response, id) {
+        await this.doOnId(response, id, async (row) => {
+            if (!this.repository.getEntityRef(row).apiDeleteAllowed) {
+                response.forbidden();
+                return;
+            }
+            await this.repository.getEntityRef(row).delete();
+            response.deleted();
         });
-    };
-    DataApi.defaultGetLimit = 0;
-    return DataApi;
-}());
-exports.DataApi = DataApi;
-function determineSort(sortUrlParm, dirUrlParam) {
-    var dirItems = [];
+    }
+    async post(response, body) {
+        try {
+            let newr = this.repository.create();
+            await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(body);
+            if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                response.forbidden();
+                return;
+            }
+            await this.repository.getEntityRef(newr).save();
+            response.created(this.repository.getEntityRef(newr).toApiJson());
+        }
+        catch (err) {
+            response.error(err);
+        }
+    }
+}
+DataApi.defaultGetLimit = 0;
+export function determineSort(sortUrlParm, dirUrlParam) {
+    let dirItems = [];
     if (dirUrlParam)
         dirItems = dirUrlParam.split(',');
-    var result = {};
-    sortUrlParm.split(',').map(function (name, i) {
-        var key = name.trim();
+    let result = {};
+    sortUrlParm.split(',').map((name, i) => {
+        let key = name.trim();
         if (i < dirItems.length && dirItems[i].toLowerCase().trim().startsWith("d"))
             return result[key] = "desc";
         else
@@ -353,16 +191,14 @@ function determineSort(sortUrlParm, dirUrlParam) {
     });
     return result;
 }
-exports.determineSort = determineSort;
-function serializeError(data) {
+export function serializeError(data) {
     if (data instanceof TypeError) {
         data = { message: data.message, stack: data.stack };
     }
-    var x = JSON.parse(JSON.stringify(data));
+    let x = JSON.parse(JSON.stringify(data));
     if (!x.message && !x.modelState)
         data = { message: data.message, stack: data.stack };
     if (typeof x === 'string')
         data = { message: x };
     return data;
 }
-exports.serializeError = serializeError;

package/src/data-interfaces.js

@@ -1,16 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSort = void 0;
-var sort_1 = require("./sort");
-function extractSort(sort) {
-    if (sort instanceof sort_1.Sort)
+import { Sort } from './sort';
+export function extractSort(sort) {
+    if (sort instanceof Sort)
         return sort;
     if (sort instanceof Array) {
-        var r_1 = new sort_1.Sort();
-        sort.forEach(function (i) {
-            r_1.Segments.push(i);
+        let r = new Sort();
+        sort.forEach(i => {
+            r.Segments.push(i);
         });
-        return r_1;
+        return r;
     }
 }
-exports.extractSort = extractSort;