remult 0.14.6 → 0.14.7

package/src/data-api.js

@@ -1,18 +1,22 @@
-import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
-import { Filter } from './filter/filter-interfaces';
-export class DataApi {
-    constructor(repository, remult) {
+"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) {
         this.repository = repository;
         this.remult = remult;
     }
-    httpGet(res, req) {
+    DataApi.prototype.httpGet = function (res, req) {
         if (req.get("__action") == "count") {
             return this.count(res, req);
         }
         else
             return this.getArray(res, req);
-    }
-    httpPost(res, req, body) {
+    };
+    DataApi.prototype.httpPost = function (res, req, body) {
         switch (req.get("__action")) {
             case "get":
                 return this.getArray(res, req, body);
@@ -21,169 +25,327 @@ export class DataApi {
             default:
                 return this.post(res, body);
         }
-    }
-    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.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*/];
                 }
-                if (!hasId) {
-                    response.forbidden();
-                    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*/];
                 }
-            }
-            if (request) {
-                let sort = request.get("_sort");
-                if (sort != undefined) {
-                    let dir = request.get('_order');
-                    findOptions.orderBy = determineSort(sort, dir);
+            });
+        });
+    };
+    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*/];
                 }
-                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())));
             });
-        }
-        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;
+        });
+    };
+    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 }];
                 }
-            }));
-        }
-        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());
         });
-    }
-    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.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*/];
+                }
+            });
         });
-    }
-    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 = [];
+    };
+    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*/];
+                }
+            });
+        });
+    };
+    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*/];
+                }
+            });
+        });
+    };
+    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*/];
+                }
+            });
+        });
+    };
+    DataApi.defaultGetLimit = 0;
+    return DataApi;
+}());
+exports.DataApi = DataApi;
+function determineSort(sortUrlParm, dirUrlParam) {
+    var dirItems = [];
     if (dirUrlParam)
         dirItems = dirUrlParam.split(',');
-    let result = {};
-    sortUrlParm.split(',').map((name, i) => {
-        let key = name.trim();
+    var result = {};
+    sortUrlParm.split(',').map(function (name, i) {
+        var key = name.trim();
         if (i < dirItems.length && dirItems[i].toLowerCase().trim().startsWith("d"))
             return result[key] = "desc";
         else
@@ -191,14 +353,16 @@ export function determineSort(sortUrlParm, dirUrlParam) {
     });
     return result;
 }
-export function serializeError(data) {
+exports.determineSort = determineSort;
+function serializeError(data) {
     if (data instanceof TypeError) {
         data = { message: data.message, stack: data.stack };
     }
-    let x = JSON.parse(JSON.stringify(data));
+    var 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,12 +1,16 @@
-import { Sort } from './sort';
-export function extractSort(sort) {
-    if (sort instanceof Sort)
+"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)
         return sort;
     if (sort instanceof Array) {
-        let r = new Sort();
-        sort.forEach(i => {
-            r.Segments.push(i);
+        var r_1 = new sort_1.Sort();
+        sort.forEach(function (i) {
+            r_1.Segments.push(i);
         });
-        return r;
+        return r_1;
     }
 }
+exports.extractSort = extractSort;