remult 0.14.6 → 0.14.7

package/src/data-providers/json-data-provider.js

@@ -1,52 +1,88 @@
-import { ArrayEntityDataProvider } from './array-entity-data-provider';
-export class JsonDataProvider {
-    constructor(storage) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonDataProvider = void 0;
+var tslib_1 = require("tslib");
+var array_entity_data_provider_1 = require("./array-entity-data-provider");
+var JsonDataProvider = /** @class */ (function () {
+    function JsonDataProvider(storage) {
         this.storage = storage;
     }
-    getEntityDataProvider(entity) {
+    JsonDataProvider.prototype.getEntityDataProvider = function (entity) {
         return new JsonEntityDataProvider(entity, this.storage);
-    }
-    async transaction(action) {
-        await action(this);
-    }
-}
-class JsonEntityDataProvider {
-    constructor(entity, helper) {
+    };
+    JsonDataProvider.prototype.transaction = function (action) {
+        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*/, action(this)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return JsonDataProvider;
+}());
+exports.JsonDataProvider = JsonDataProvider;
+var JsonEntityDataProvider = /** @class */ (function () {
+    function JsonEntityDataProvider(entity, helper) {
         this.entity = entity;
         this.helper = helper;
         this.p = Promise.resolve();
     }
-    async loadEntityData(what) {
-        let data = [];
-        let dbName = await this.entity.getDbName();
-        let s = this.helper.getItem(dbName);
-        if (s)
-            data = JSON.parse(s);
-        let dp = new ArrayEntityDataProvider(this.entity, data);
-        return what(dp, () => this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
-    }
-    find(options) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.find(options)));
-    }
-    count(where) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.count(where)));
-    }
-    update(id, data) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then(x => {
+    JsonEntityDataProvider.prototype.loadEntityData = function (what) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var data, dbName, s, dp;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = [];
+                        return [4 /*yield*/, this.entity.getDbName()];
+                    case 1:
+                        dbName = _a.sent();
+                        s = this.helper.getItem(dbName);
+                        if (s)
+                            data = JSON.parse(s);
+                        dp = new array_entity_data_provider_1.ArrayEntityDataProvider(this.entity, data);
+                        return [2 /*return*/, what(dp, function () { return _this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)); })];
+                }
+            });
+        });
+    };
+    JsonEntityDataProvider.prototype.find = function (options) {
+        var _this = this;
+        return this.p = this.p.then(function () { return _this.loadEntityData(function (dp, save) { return dp.find(options); }); });
+    };
+    JsonEntityDataProvider.prototype.count = function (where) {
+        var _this = this;
+        return this.p = this.p.then(function () { return _this.loadEntityData(function (dp, save) { return dp.count(where); }); });
+    };
+    JsonEntityDataProvider.prototype.update = function (id, data) {
+        var _this = this;
+        return this.p = this.p.then(function () { return _this.loadEntityData(function (dp, save) { return dp.update(id, data).then(function (x) {
             save();
             return x;
-        })));
-    }
-    delete(id) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then(x => {
+        }); }); });
+    };
+    JsonEntityDataProvider.prototype.delete = function (id) {
+        var _this = this;
+        return this.p = this.p.then(function () { return _this.loadEntityData(function (dp, save) { return dp.delete(id).then(function (x) {
             save();
             return x;
-        })));
-    }
-    async insert(data) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then(x => {
-            save();
-            return x;
-        })));
-    }
-}
+        }); }); });
+    };
+    JsonEntityDataProvider.prototype.insert = function (data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, this.p = this.p.then(function () { return _this.loadEntityData(function (dp, save) { return dp.insert(data).then(function (x) {
+                        save();
+                        return x;
+                    }); }); })];
+            });
+        });
+    };
+    return JsonEntityDataProvider;
+}());

package/src/data-providers/rest-data-provider.js

@@ -1,56 +1,94 @@
-import { UrlBuilder } from '../../urlBuilder';
-import { customUrlToken } from '../filter/filter-interfaces';
-import { retry } from '../context';
-export class RestDataProvider {
-    constructor(url, http) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addFilterToUrlAndReturnTrueIfSuccessful = exports.RestDataProviderHttpProviderUsingFetch = exports.RestEntityDataProvider = exports.RestDataProvider = void 0;
+var tslib_1 = require("tslib");
+var urlBuilder_1 = require("../../urlBuilder");
+var filter_interfaces_1 = require("../filter/filter-interfaces");
+var context_1 = require("../context");
+var RestDataProvider = /** @class */ (function () {
+    function RestDataProvider(url, http) {
         this.url = url;
         this.http = http;
         this.supportsCustomFilter = true;
     }
-    getEntityDataProvider(entity) {
+    RestDataProvider.prototype.getEntityDataProvider = function (entity) {
         return new RestEntityDataProvider(this.url + '/' + entity.key, this.http, entity);
-    }
-    async transaction(action) {
-        throw new Error("Method not implemented.");
-    }
-}
-export class RestEntityDataProvider {
-    constructor(url, http, entity) {
+    };
+    RestDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw new Error("Method not implemented.");
+            });
+        });
+    };
+    return RestDataProvider;
+}());
+exports.RestDataProvider = RestDataProvider;
+var RestEntityDataProvider = /** @class */ (function () {
+    function RestEntityDataProvider(url, http, entity) {
         this.url = url;
         this.http = http;
         this.entity = entity;
     }
-    translateFromJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromJson(row[col.key]);
+    RestEntityDataProvider.prototype.translateFromJson = function (row) {
+        var e_1, _a;
+        var result = {};
+        try {
+            for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var col = _c.value;
+                result[col.key] = col.valueConverter.fromJson(row[col.key]);
+            }
         }
-        return result;
-    }
-    translateToJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.toJson(row[col.key]);
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return result;
-    }
-    async count(where) {
-        let url = new UrlBuilder(this.url);
-        url.add("__action", "count");
-        let filterObject;
-        if (where) {
-            filterObject = where.toJson();
-            if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
-                filterObject = undefined;
+    };
+    RestEntityDataProvider.prototype.translateToJson = function (row) {
+        var e_2, _a;
+        var result = {};
+        try {
+            for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var col = _c.value;
+                result[col.key] = col.valueConverter.toJson(row[col.key]);
+            }
         }
-        if (filterObject)
-            return this.http.post(url.url, filterObject).then(r => +(r.count));
-        else
-            return this.http.get(url.url).then(r => +(r.count));
-    }
-    find(options) {
-        let url = new UrlBuilder(this.url);
-        let filterObject;
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return result;
+    };
+    RestEntityDataProvider.prototype.count = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var url, filterObject;
+            return tslib_1.__generator(this, function (_a) {
+                url = new urlBuilder_1.UrlBuilder(this.url);
+                url.add("__action", "count");
+                if (where) {
+                    filterObject = where.toJson();
+                    if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
+                        filterObject = undefined;
+                }
+                if (filterObject)
+                    return [2 /*return*/, this.http.post(url.url, filterObject).then(function (r) { return +(r.count); })];
+                else
+                    return [2 /*return*/, this.http.get(url.url).then(function (r) { return +(r.count); })];
+                return [2 /*return*/];
+            });
+        });
+    };
+    RestEntityDataProvider.prototype.find = function (options) {
+        var _this = this;
+        var url = new urlBuilder_1.UrlBuilder(this.url);
+        var filterObject;
         if (options) {
             if (options.where) {
                 filterObject = options.where.toJson(); //        options.where.__applyToConsumer(new FilterConsumnerBridgeToUrlBuilder(url));
@@ -58,18 +96,18 @@ export class RestEntityDataProvider {
                     filterObject = undefined;
             }
             if (options.orderBy && options.orderBy.Segments) {
-                let sort = '';
-                let order = '';
-                options.orderBy.Segments.forEach(c => {
-                    if (sort.length > 0) {
-                        sort += ",";
-                        order += ",";
+                var sort_1 = '';
+                var order_1 = '';
+                options.orderBy.Segments.forEach(function (c) {
+                    if (sort_1.length > 0) {
+                        sort_1 += ",";
+                        order_1 += ",";
                     }
-                    sort += c.field.key;
-                    order += c.isDescending ? "desc" : "asc";
+                    sort_1 += c.field.key;
+                    order_1 += c.isDescending ? "desc" : "asc";
                 });
-                url.add('_sort', sort);
-                url.add('_order', order);
+                url.add('_sort', sort_1);
+                url.add('_order', order_1);
             }
             if (options.limit)
                 url.add('_limit', options.limit);
@@ -78,53 +116,89 @@ export class RestEntityDataProvider {
         }
         if (filterObject) {
             url.add("__action", "get");
-            return this.http.post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
+            return this.http.post(url.url, filterObject).then(function (x) { return x.map(function (y) { return _this.translateFromJson(y); }); });
         }
         else
-            return this.http.get(url.url).then(x => x.map(y => this.translateFromJson(y)));
+            return this.http.get(url.url).then(function (x) { return x.map(function (y) { return _this.translateFromJson(y); }); });
         ;
-    }
-    update(id, data) {
-        let result = {};
-        let keys = Object.keys(data);
-        for (const col of this.entity.fields) {
-            if (keys.includes(col.key))
-                result[col.key] = col.valueConverter.toJson(data[col.key]);
+    };
+    RestEntityDataProvider.prototype.update = function (id, data) {
+        var e_3, _a;
+        var _this = this;
+        var result = {};
+        var keys = Object.keys(data);
+        try {
+            for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var col = _c.value;
+                if (keys.includes(col.key))
+                    result[col.key] = col.valueConverter.toJson(data[col.key]);
+            }
         }
-        return this.http.put(this.url + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
-    }
-    delete(id) {
+        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; }
+        }
+        return this.http.put(this.url + '/' + encodeURIComponent(id), result).then(function (y) { return _this.translateFromJson(y); });
+    };
+    RestEntityDataProvider.prototype.delete = function (id) {
         return this.http.delete(this.url + '/' + encodeURIComponent(id));
-    }
-    insert(data) {
-        return this.http.post(this.url, this.translateToJson(data)).then(y => this.translateFromJson(y));
-    }
-}
-export class RestDataProviderHttpProviderUsingFetch {
-    constructor(fetch) {
+    };
+    RestEntityDataProvider.prototype.insert = function (data) {
+        var _this = this;
+        return this.http.post(this.url, this.translateToJson(data)).then(function (y) { return _this.translateFromJson(y); });
+    };
+    return RestEntityDataProvider;
+}());
+exports.RestEntityDataProvider = RestEntityDataProvider;
+var RestDataProviderHttpProviderUsingFetch = /** @class */ (function () {
+    function RestDataProviderHttpProviderUsingFetch(fetch) {
         this.fetch = fetch;
     }
-    async get(url) {
-        return await retry(async () => this.myFetch(url).then(r => {
-            return r;
-        }));
-    }
-    put(url, data) {
+    RestDataProviderHttpProviderUsingFetch.prototype.get = function (url) {
+        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*/, context_1.retry(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                return [2 /*return*/, this.myFetch(url).then(function (r) {
+                                        return r;
+                                    })];
+                            });
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    RestDataProviderHttpProviderUsingFetch.prototype.put = function (url, data) {
         return this.myFetch(url, {
             method: 'put',
             body: JSON.stringify(data)
         });
-    }
-    delete(url) {
+    };
+    RestDataProviderHttpProviderUsingFetch.prototype.delete = function (url) {
         return this.myFetch(url, { method: 'delete', credentials: 'include' });
-    }
-    async post(url, data) {
-        return await retry(() => this.myFetch(url, {
-            method: 'post',
-            body: JSON.stringify(data)
-        }));
-    }
-    myFetch(url, init) {
+    };
+    RestDataProviderHttpProviderUsingFetch.prototype.post = function (url, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, context_1.retry(function () { return _this.myFetch(url, {
+                            method: 'post',
+                            body: JSON.stringify(data)
+                        }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    RestDataProviderHttpProviderUsingFetch.prototype.myFetch = function (url, init) {
+        var _this = this;
         if (!init)
             init = {};
         if (!init.headers)
@@ -132,23 +206,32 @@ export class RestDataProviderHttpProviderUsingFetch {
         var h = init.headers;
         h.append('Content-type', "application/json");
         init.credentials = 'include';
-        return (this.fetch || fetch)(url, init).then(response => {
+        return (this.fetch || fetch)(url, init).then(function (response) {
             return onSuccess(response);
-        }).catch(async (error) => {
-            let r = await error;
-            throw r;
-        });
-    }
-}
+        }).catch(function (error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var r;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, error];
+                    case 1:
+                        r = _a.sent();
+                        throw r;
+                }
+            });
+        }); });
+    };
+    return RestDataProviderHttpProviderUsingFetch;
+}());
+exports.RestDataProviderHttpProviderUsingFetch = RestDataProviderHttpProviderUsingFetch;
 function onSuccess(response) {
     if (response.status == 204)
         return;
     if (response.status >= 200 && response.status < 300)
         return response.json();
     else {
-        throw response.json().then(x => {
-            return { ...x, message: x.message || response.statusText, url: response.url, status: response.status };
-        }).catch(() => {
+        throw response.json().then(function (x) {
+            return tslib_1.__assign(tslib_1.__assign({}, x), { message: x.message || response.statusText, url: response.url, status: response.status });
+        }).catch(function () {
             throw {
                 message: response.statusText,
                 url: response.url,
@@ -157,10 +240,10 @@ function onSuccess(response) {
         });
     }
 }
-export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
-    for (const key in filter) {
+function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
+    for (var key in filter) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {
-            const element = filter[key];
+            var element = filter[key];
             if (Array.isArray(element)) {
                 if (element.length > 0 && typeof element[0] === 'object')
                     return false;
@@ -169,20 +252,24 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
             }
         }
     }
-    for (const key in filter) {
+    var _loop_1 = function (key) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {
-            const element = filter[key];
+            var element = filter[key];
             if (Array.isArray(element)) {
                 if (key.endsWith("_in"))
                     url.add(key, JSON.stringify(element));
                 else
-                    element.forEach(e => url.add(key, e));
+                    element.forEach(function (e) { return url.add(key, e); });
             }
-            else if (key.startsWith(customUrlToken))
+            else if (key.startsWith(filter_interfaces_1.customUrlToken))
                 url.add(key, JSON.stringify(element));
             else
                 url.add(key, element);
         }
+    };
+    for (var key in filter) {
+        _loop_1(key);
     }
     return true;
 }
+exports.addFilterToUrlAndReturnTrueIfSuccessful = addFilterToUrlAndReturnTrueIfSuccessful;