remult 0.14.6 → 0.14.7

package/src/data-providers/array-entity-data-provider.js

@@ -1,264 +1,379 @@
-import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
-import { CompoundIdField } from '../column';
-export class ArrayEntityDataProvider {
-    constructor(entity, rows) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayEntityDataProvider = void 0;
+var tslib_1 = require("tslib");
+var filter_interfaces_1 = require("../filter/filter-interfaces");
+var column_1 = require("../column");
+var ArrayEntityDataProvider = /** @class */ (function () {
+    function ArrayEntityDataProvider(entity, rows) {
+        var e_1, _a;
         this.entity = entity;
         this.rows = rows;
         if (!rows)
             rows = [];
         else {
-            for (const r of rows) {
-                this.verifyThatRowHasAllNotNullColumns(r);
+            try {
+                for (var rows_1 = tslib_1.__values(rows), rows_1_1 = rows_1.next(); !rows_1_1.done; rows_1_1 = rows_1.next()) {
+                    var r = rows_1_1.value;
+                    this.verifyThatRowHasAllNotNullColumns(r);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (rows_1_1 && !rows_1_1.done && (_a = rows_1.return)) _a.call(rows_1);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
         }
     }
-    static customFilter(filter) {
-        return {
-            [customDatabaseFilterToken]: {
+    ArrayEntityDataProvider.customFilter = function (filter) {
+        var _a;
+        return _a = {},
+            _a[filter_interfaces_1.customDatabaseFilterToken] = {
                 arrayFilter: filter
-            }
-        };
-    }
-    verifyThatRowHasAllNotNullColumns(r) {
-        for (const f of this.entity.fields) {
-            if (!f.isServerExpression)
-                if (!f.allowNull) {
-                    if (r[f.key] === undefined || r[f.key] === null) {
-                        let val = undefined;
-                        if (f.valueType === Boolean)
-                            val = false;
-                        else if (f.valueType === Number)
-                            val = 0;
-                        else if (f.valueType === String)
-                            val = '';
-                        r[f.key] = val;
+            },
+            _a;
+    };
+    ArrayEntityDataProvider.prototype.verifyThatRowHasAllNotNullColumns = function (r) {
+        var e_2, _a;
+        try {
+            for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var f = _c.value;
+                if (!f.isServerExpression)
+                    if (!f.allowNull) {
+                        if (r[f.key] === undefined || r[f.key] === null) {
+                            var val = undefined;
+                            if (f.valueType === Boolean)
+                                val = false;
+                            else if (f.valueType === Number)
+                                val = 0;
+                            else if (f.valueType === String)
+                                val = '';
+                            r[f.key] = val;
+                        }
                     }
-                }
-                else if (r[f.key] === undefined)
-                    r[f.key] = null;
-        }
-    }
-    async count(where) {
-        let rows = this.rows;
-        let j = 0;
-        for (let i = 0; i < rows.length; i++) {
-            if (!where) {
-                j++;
-            }
-            else {
-                let x = new FilterConsumerBridgeToObject(rows[i]);
-                where.__applyToConsumer(x);
-                if (x.ok)
-                    j++;
+                    else if (r[f.key] === undefined)
+                        r[f.key] = null;
             }
         }
-        return j;
-    }
-    async find(options) {
-        let rows = this.rows;
-        if (options) {
-            if (options.where) {
-                rows = rows.filter(i => {
-                    let x = new FilterConsumerBridgeToObject(i);
-                    options.where.__applyToConsumer(x);
-                    return x.ok;
-                });
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            if (options.orderBy) {
-                rows = rows.sort((a, b) => {
-                    let r = 0;
-                    for (let i = 0; i < options.orderBy.Segments.length; i++) {
-                        let seg = options.orderBy.Segments[i];
-                        let left = a[seg.field.key];
-                        let right = b[seg.field.key];
-                        if (left > right)
-                            r = 1;
-                        else if (left < right)
-                            r = -1;
-                        if (r != 0) {
-                            if (seg.isDescending)
-                                r *= -1;
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    ArrayEntityDataProvider.prototype.count = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var rows, j, i, x;
+            return tslib_1.__generator(this, function (_a) {
+                rows = this.rows;
+                j = 0;
+                for (i = 0; i < rows.length; i++) {
+                    if (!where) {
+                        j++;
+                    }
+                    else {
+                        x = new FilterConsumerBridgeToObject(rows[i]);
+                        where.__applyToConsumer(x);
+                        if (x.ok)
+                            j++;
+                    }
+                }
+                return [2 /*return*/, j];
+            });
+        });
+    };
+    ArrayEntityDataProvider.prototype.find = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var rows;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                rows = this.rows;
+                if (options) {
+                    if (options.where) {
+                        rows = rows.filter(function (i) {
+                            var x = new FilterConsumerBridgeToObject(i);
+                            options.where.__applyToConsumer(x);
+                            return x.ok;
+                        });
+                    }
+                    if (options.orderBy) {
+                        rows = rows.sort(function (a, b) {
+                            var r = 0;
+                            for (var i = 0; i < options.orderBy.Segments.length; i++) {
+                                var seg = options.orderBy.Segments[i];
+                                var left = a[seg.field.key];
+                                var right = b[seg.field.key];
+                                if (left > right)
+                                    r = 1;
+                                else if (left < right)
+                                    r = -1;
+                                if (r != 0) {
+                                    if (seg.isDescending)
+                                        r *= -1;
+                                    return r;
+                                }
+                            }
                             return r;
-                        }
+                        });
                     }
-                    return r;
-                });
+                    rows = pageArray(rows, options);
+                }
+                if (rows)
+                    return [2 /*return*/, rows.map(function (i) {
+                            return _this.translateFromJson(i);
+                        })];
+                return [2 /*return*/];
+            });
+        });
+    };
+    ArrayEntityDataProvider.prototype.translateFromJson = function (row) {
+        var e_3, _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]);
             }
-            rows = pageArray(rows, options);
         }
-        if (rows)
-            return rows.map(i => {
-                return this.translateFromJson(i);
-            });
-    }
-    translateFromJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromJson(row[col.key]);
+        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 result;
-    }
-    translateToJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.toJson(row[col.key]);
+    };
+    ArrayEntityDataProvider.prototype.translateToJson = function (row) {
+        var e_4, _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]);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
         }
         return result;
-    }
-    idMatches(id) {
-        return item => {
-            let x = new FilterConsumerBridgeToObject(item);
-            Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(x);
+    };
+    ArrayEntityDataProvider.prototype.idMatches = function (id) {
+        var _this = this;
+        return function (item) {
+            var x = new FilterConsumerBridgeToObject(item);
+            filter_interfaces_1.Filter.fromEntityFilter(_this.entity, _this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(x);
             return x.ok;
         };
-    }
-    update(id, data) {
-        let idMatches = this.idMatches(id);
-        let keys = Object.keys(data);
-        for (let i = 0; i < this.rows.length; i++) {
-            let r = this.rows[i];
+    };
+    ArrayEntityDataProvider.prototype.update = function (id, data) {
+        var e_5, _a;
+        var idMatches = this.idMatches(id);
+        var keys = Object.keys(data);
+        for (var i = 0; i < this.rows.length; i++) {
+            var r = this.rows[i];
             if (idMatches(r)) {
-                let newR = { ...r };
-                for (const f of this.entity.fields) {
-                    if (!f.dbReadOnly && !f.isServerExpression) {
-                        if (keys.includes(f.key)) {
-                            newR[f.key] = f.valueConverter.toJson(data[f.key]);
+                var newR = tslib_1.__assign({}, r);
+                try {
+                    for (var _b = (e_5 = void 0, tslib_1.__values(this.entity.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var f = _c.value;
+                        if (!f.dbReadOnly && !f.isServerExpression) {
+                            if (keys.includes(f.key)) {
+                                newR[f.key] = f.valueConverter.toJson(data[f.key]);
+                            }
                         }
                     }
                 }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
                 this.verifyThatRowHasAllNotNullColumns(newR);
                 this.rows[i] = newR;
                 return Promise.resolve(this.translateFromJson(this.rows[i]));
             }
         }
         throw new Error("couldn't find id to update: " + id);
-    }
-    delete(id) {
-        let idMatches = this.idMatches(id);
-        for (let i = 0; i < this.rows.length; i++) {
+    };
+    ArrayEntityDataProvider.prototype.delete = function (id) {
+        var idMatches = this.idMatches(id);
+        for (var i = 0; i < this.rows.length; i++) {
             if (idMatches(this.rows[i])) {
                 this.rows.splice(i, 1);
                 return Promise.resolve();
             }
         }
         throw new Error("couldn't find id to delete: " + id);
-    }
-    async insert(data) {
-        let idf = this.entity.idMetadata.field;
-        if (!(idf instanceof CompoundIdField)) {
-            if (idf.options.valueConverter?.fieldTypeInDb === 'autoincrement') {
-                data[idf.key] = 1;
-                for (const row of this.rows) {
-                    if (row[idf.key] >= data[idf.key])
-                        data[idf.key] = row[idf.key] + 1;
+    };
+    ArrayEntityDataProvider.prototype.insert = function (data) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var idf, _b, _c, row, j;
+            var e_6, _d;
+            return tslib_1.__generator(this, function (_e) {
+                idf = this.entity.idMetadata.field;
+                if (!(idf instanceof column_1.CompoundIdField)) {
+                    if (((_a = idf.options.valueConverter) === null || _a === void 0 ? void 0 : _a.fieldTypeInDb) === 'autoincrement') {
+                        data[idf.key] = 1;
+                        try {
+                            for (_b = tslib_1.__values(this.rows), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                row = _c.value;
+                                if (row[idf.key] >= data[idf.key])
+                                    data[idf.key] = row[idf.key] + 1;
+                            }
+                        }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_d = _b.return)) _d.call(_b);
+                            }
+                            finally { if (e_6) throw e_6.error; }
+                        }
+                    }
+                    if (data[idf.key])
+                        this.rows.forEach(function (i) {
+                            if (data[idf.key] == i[idf.key])
+                                throw Error("id already exists");
+                        });
                 }
-            }
-            if (data[idf.key])
-                this.rows.forEach(i => {
-                    if (data[idf.key] == i[idf.key])
-                        throw Error("id already exists");
-                });
-        }
-        let j = this.translateToJson(data);
-        this.verifyThatRowHasAllNotNullColumns(j);
-        this.rows.push(j);
-        return Promise.resolve(this.translateFromJson(j));
-    }
-}
+                j = this.translateToJson(data);
+                this.verifyThatRowHasAllNotNullColumns(j);
+                this.rows.push(j);
+                return [2 /*return*/, Promise.resolve(this.translateFromJson(j))];
+            });
+        });
+    };
+    return ArrayEntityDataProvider;
+}());
+exports.ArrayEntityDataProvider = ArrayEntityDataProvider;
 function pageArray(rows, options) {
     if (!options)
         return rows;
     if (!options.limit)
         return rows;
-    let page = 1;
+    var page = 1;
     if (options.page)
         page = options.page;
     if (page < 1)
         page = 1;
-    let x = 0;
-    return rows.filter(i => {
+    var x = 0;
+    return rows.filter(function (i) {
         x++;
-        let max = page * options.limit;
-        let min = max - options.limit;
+        var max = page * options.limit;
+        var min = max - options.limit;
         return x > min && x <= max;
     });
 }
-class FilterConsumerBridgeToObject {
-    constructor(row) {
+var FilterConsumerBridgeToObject = /** @class */ (function () {
+    function FilterConsumerBridgeToObject(row) {
         this.row = row;
         this.ok = true;
     }
-    databaseCustom(databaseCustom) {
+    FilterConsumerBridgeToObject.prototype.databaseCustom = function (databaseCustom) {
         if (databaseCustom && databaseCustom.arrayFilter) {
             if (!databaseCustom.arrayFilter(this.row))
                 this.ok = false;
         }
-    }
-    custom(key, customItem) {
+    };
+    FilterConsumerBridgeToObject.prototype.custom = function (key, customItem) {
         throw new Error('Custom Filter should be translated before it gets here');
-    }
-    or(orElements) {
-        for (const element of orElements) {
-            let filter = new FilterConsumerBridgeToObject(this.row);
-            element.__applyToConsumer(filter);
-            if (filter.ok) {
-                return;
+    };
+    FilterConsumerBridgeToObject.prototype.or = function (orElements) {
+        var e_7, _a;
+        try {
+            for (var orElements_1 = tslib_1.__values(orElements), orElements_1_1 = orElements_1.next(); !orElements_1_1.done; orElements_1_1 = orElements_1.next()) {
+                var element = orElements_1_1.value;
+                var filter = new FilterConsumerBridgeToObject(this.row);
+                element.__applyToConsumer(filter);
+                if (filter.ok) {
+                    return;
+                }
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (orElements_1_1 && !orElements_1_1.done && (_a = orElements_1.return)) _a.call(orElements_1);
             }
+            finally { if (e_7) throw e_7.error; }
         }
         this.ok = false;
-    }
-    isNull(col) {
+    };
+    FilterConsumerBridgeToObject.prototype.isNull = function (col) {
         if (this.row[col.key] != null)
             this.ok = false;
-    }
-    isNotNull(col) {
+    };
+    FilterConsumerBridgeToObject.prototype.isNotNull = function (col) {
         if (this.row[col.key] == null)
             this.ok = false;
-    }
-    isIn(col, val) {
-        for (const v of val) {
-            if (this.row[col.key] == col.valueConverter.toJson(v)) {
-                return;
+    };
+    FilterConsumerBridgeToObject.prototype.isIn = function (col, val) {
+        var e_8, _a;
+        try {
+            for (var val_1 = tslib_1.__values(val), val_1_1 = val_1.next(); !val_1_1.done; val_1_1 = val_1.next()) {
+                var v = val_1_1.value;
+                if (this.row[col.key] == col.valueConverter.toJson(v)) {
+                    return;
+                }
             }
         }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (val_1_1 && !val_1_1.done && (_a = val_1.return)) _a.call(val_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
         this.ok = false;
-    }
-    isEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToObject.prototype.isEqualTo = function (col, val) {
         if (this.row[col.key] != col.valueConverter.toJson(val))
             this.ok = false;
-    }
-    isDifferentFrom(col, val) {
+    };
+    FilterConsumerBridgeToObject.prototype.isDifferentFrom = function (col, val) {
         if (this.row[col.key] == col.valueConverter.toJson(val))
             this.ok = false;
-    }
-    isGreaterOrEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToObject.prototype.isGreaterOrEqualTo = function (col, val) {
         if (this.row[col.key] < col.valueConverter.toJson(val))
             this.ok = false;
-    }
-    isGreaterThan(col, val) {
+    };
+    FilterConsumerBridgeToObject.prototype.isGreaterThan = function (col, val) {
         if (this.row[col.key] <= col.valueConverter.toJson(val))
             this.ok = false;
-    }
-    isLessOrEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToObject.prototype.isLessOrEqualTo = function (col, val) {
         if (this.row[col.key] > col.valueConverter.toJson(val))
             this.ok = false;
-    }
-    isLessThan(col, val) {
+    };
+    FilterConsumerBridgeToObject.prototype.isLessThan = function (col, val) {
         if (this.row[col.key] >= col.valueConverter.toJson(val))
             this.ok = false;
-    }
-    containsCaseInsensitive(col, val) {
-        let v = this.row[col.key];
+    };
+    FilterConsumerBridgeToObject.prototype.containsCaseInsensitive = function (col, val) {
+        var v = this.row[col.key];
         if (!v) {
             this.ok = false;
             return;
         }
-        let s = '' + v;
+        var s = '' + v;
         if (val)
             val = col.valueConverter.toJson(val);
         if (val)
             val = val.toString().toLowerCase();
         if (s.toLowerCase().indexOf(val) < 0)
             this.ok = false;
-    }
-}
+    };
+    return FilterConsumerBridgeToObject;
+}());

package/src/data-providers/in-memory-database.js

@@ -1,16 +1,31 @@
-import { ArrayEntityDataProvider } from './array-entity-data-provider';
-export class InMemoryDataProvider {
-    constructor() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryDataProvider = void 0;
+var tslib_1 = require("tslib");
+var array_entity_data_provider_1 = require("./array-entity-data-provider");
+var InMemoryDataProvider = /** @class */ (function () {
+    function InMemoryDataProvider() {
         this.rows = {};
     }
-    async transaction(action) {
-        await action(this);
-    }
-    getEntityDataProvider(entity) {
-        let name = entity.key;
+    InMemoryDataProvider.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*/];
+                }
+            });
+        });
+    };
+    InMemoryDataProvider.prototype.getEntityDataProvider = function (entity) {
+        var name = entity.key;
         if (!this.rows[name])
             this.rows[name] = [];
-        return new ArrayEntityDataProvider(entity, this.rows[name]);
-    }
-    toString() { return "InMemoryDataProvider"; }
-}
+        return new array_entity_data_provider_1.ArrayEntityDataProvider(entity, this.rows[name]);
+    };
+    InMemoryDataProvider.prototype.toString = function () { return "InMemoryDataProvider"; };
+    return InMemoryDataProvider;
+}());
+exports.InMemoryDataProvider = InMemoryDataProvider;