remult 0.14.6 → 0.14.7

package/remult-mongo.js

@@ -1,211 +1,444 @@
-import { CompoundIdField, Filter } from '.';
-import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
-export class MongoDataProvider {
-    constructor(db, client) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDataProvider = void 0;
+var tslib_1 = require("tslib");
+var _1 = require(".");
+var filter_consumer_bridge_to_sql_request_1 = require("./src/filter/filter-consumer-bridge-to-sql-request");
+var MongoDataProvider = /** @class */ (function () {
+    function MongoDataProvider(db, client) {
         this.db = db;
         this.client = client;
     }
-    getEntityDataProvider(entity) {
+    MongoDataProvider.prototype.getEntityDataProvider = function (entity) {
         return new MongoEntityDataProvider(this.db, entity);
-    }
-    async transaction(action) {
-        let session = await this.client.startSession();
-        session.startTransaction();
-        try {
-            await action(new MongoDataProvider(this.db, undefined));
-            await session.commitTransaction();
-        }
-        catch (err) {
-            await session.abortTransaction();
-            throw err;
-        }
-    }
-}
-const NULL = { $null: "$null" };
+    };
+    MongoDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var session, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.startSession()];
+                    case 1:
+                        session = _a.sent();
+                        session.startTransaction();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 5, , 7]);
+                        return [4 /*yield*/, action(new MongoDataProvider(this.db, undefined))];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, session.commitTransaction()];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
+                        err_1 = _a.sent();
+                        return [4 /*yield*/, session.abortTransaction()];
+                    case 6:
+                        _a.sent();
+                        throw err_1;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return MongoDataProvider;
+}());
+exports.MongoDataProvider = MongoDataProvider;
+var NULL = { $null: "$null" };
 function isNull(x) {
-    return x?.$null === NULL.$null;
+    return (x === null || x === void 0 ? void 0 : x.$null) === NULL.$null;
 }
-class MongoEntityDataProvider {
-    constructor(db, entity) {
+var MongoEntityDataProvider = /** @class */ (function () {
+    function MongoEntityDataProvider(db, entity) {
         this.db = db;
         this.entity = entity;
     }
-    translateFromJson(row, nameProvider) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromDb(row[nameProvider.nameOf(col)]);
-            if (isNull(result[col.key]))
-                result[col.key] = null;
-        }
-        return result;
-    }
-    translateToJson(row, nameProvider) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            let val = col.valueConverter.toDb(row[col.key]);
-            if (val === null)
-                val = NULL;
-            result[nameProvider.nameOf(col)] = val;
-        }
-        return result;
-    }
-    async count(where) {
-        const { collection, e } = await this.collection();
-        let x = new FilterConsumerBridgeToMongo(e);
-        where.__applyToConsumer(x);
-        let w = await x.resolveWhere();
-        return await collection.countDocuments(w);
-    }
-    async find(options) {
-        let { collection, e } = await this.collection();
-        let x = new FilterConsumerBridgeToMongo(e);
-        if (options?.where)
-            options.where.__applyToConsumer(x);
-        let where = await x.resolveWhere();
-        let op = {};
-        if (options.limit) {
-            op.limit = options.limit;
-            if (options.page) {
-                op.skip = (options.page - 1) * options.limit;
+    MongoEntityDataProvider.prototype.translateFromJson = function (row, nameProvider) {
+        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.fromDb(row[nameProvider.nameOf(col)]);
+                if (isNull(result[col.key]))
+                    result[col.key] = null;
             }
         }
-        if (options.orderBy) {
-            op.sort = {};
-            for (const s of options.orderBy.Segments) {
-                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
+        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 await Promise.all(await collection.find(where, op).map(x => this.translateFromJson(x, e)).toArray());
-    }
-    async update(id, data) {
-        let { collection, e } = await this.collection();
-        let f = new FilterConsumerBridgeToMongo(e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        let resultFilter = this.entity.idMetadata.getIdFilter(id);
-        if (data.id != undefined)
-            resultFilter = this.entity.idMetadata.getIdFilter(data.id);
-        for (const x of this.entity.fields) {
-            if (x instanceof CompoundIdField) {
-                resultFilter = x.resultIdFilter(id, data);
+        return result;
+    };
+    MongoEntityDataProvider.prototype.translateToJson = function (row, nameProvider) {
+        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;
+                var val = col.valueConverter.toDb(row[col.key]);
+                if (val === null)
+                    val = NULL;
+                result[nameProvider.nameOf(col)] = val;
             }
         }
-        let newR = {};
-        let keys = Object.keys(data);
-        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]);
-                }
+        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; }
         }
-        let r = await collection.updateOne(await f.resolveWhere(), {
-            $set: newR
+        return result;
+    };
+    MongoEntityDataProvider.prototype.count = function (where) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, collection, e, x, w;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.collection()];
+                    case 1:
+                        _a = _b.sent(), collection = _a.collection, e = _a.e;
+                        x = new FilterConsumerBridgeToMongo(e);
+                        where.__applyToConsumer(x);
+                        return [4 /*yield*/, x.resolveWhere()];
+                    case 2:
+                        w = _b.sent();
+                        return [4 /*yield*/, collection.countDocuments(w)];
+                    case 3: return [2 /*return*/, _b.sent()];
+                }
+            });
         });
-        return this.find({ where: Filter.fromEntityFilter(this.entity, resultFilter) }).then(y => y[0]);
-    }
-    async delete(id) {
-        const { e, collection } = await this.collection();
-        let f = new FilterConsumerBridgeToMongo(e);
-        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
-        collection.deleteOne(await f.resolveWhere());
-    }
-    async insert(data) {
-        let { collection, e } = await this.collection();
-        let r = await collection.insertOne(await this.translateToJson(data, e));
-        return await this.translateFromJson(await collection.findOne({ _id: r.insertedId }), e);
-    }
-    async collection() {
-        const e = await getDbNameProvider(this.entity);
-        const collection = this.db.collection(e.entityName);
-        return { e, collection };
-    }
-}
-class FilterConsumerBridgeToMongo {
-    constructor(nameProvider) {
+    };
+    MongoEntityDataProvider.prototype.find = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, collection, e, x, where, op, _b, _c, s, _d, _e;
+            var e_3, _f;
+            var _this = this;
+            return tslib_1.__generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0: return [4 /*yield*/, this.collection()];
+                    case 1:
+                        _a = _g.sent(), collection = _a.collection, e = _a.e;
+                        x = new FilterConsumerBridgeToMongo(e);
+                        if (options === null || options === void 0 ? void 0 : options.where)
+                            options.where.__applyToConsumer(x);
+                        return [4 /*yield*/, x.resolveWhere()];
+                    case 2:
+                        where = _g.sent();
+                        op = {};
+                        if (options.limit) {
+                            op.limit = options.limit;
+                            if (options.page) {
+                                op.skip = (options.page - 1) * options.limit;
+                            }
+                        }
+                        if (options.orderBy) {
+                            op.sort = {};
+                            try {
+                                for (_b = tslib_1.__values(options.orderBy.Segments), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                    s = _c.value;
+                                    op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
+                                }
+                            }
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                            finally {
+                                try {
+                                    if (_c && !_c.done && (_f = _b.return)) _f.call(_b);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                            }
+                        }
+                        _e = (_d = Promise).all;
+                        return [4 /*yield*/, collection.find(where, op).map(function (x) { return _this.translateFromJson(x, e); }).toArray()];
+                    case 3: return [4 /*yield*/, _e.apply(_d, [_g.sent()])];
+                    case 4: return [2 /*return*/, _g.sent()];
+                }
+            });
+        });
+    };
+    MongoEntityDataProvider.prototype.update = function (id, data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, collection, e, f, resultFilter, _b, _c, x, newR, keys, _d, _e, f_1, r, _f, _g;
+            var e_4, _h, e_5, _j;
+            return tslib_1.__generator(this, function (_k) {
+                switch (_k.label) {
+                    case 0: return [4 /*yield*/, this.collection()];
+                    case 1:
+                        _a = _k.sent(), collection = _a.collection, e = _a.e;
+                        f = new FilterConsumerBridgeToMongo(e);
+                        _1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+                        resultFilter = this.entity.idMetadata.getIdFilter(id);
+                        if (data.id != undefined)
+                            resultFilter = this.entity.idMetadata.getIdFilter(data.id);
+                        try {
+                            for (_b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                x = _c.value;
+                                if (x instanceof _1.CompoundIdField) {
+                                    resultFilter = x.resultIdFilter(id, data);
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_h = _b.return)) _h.call(_b);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                        newR = {};
+                        keys = Object.keys(data);
+                        try {
+                            for (_d = tslib_1.__values(this.entity.fields), _e = _d.next(); !_e.done; _e = _d.next()) {
+                                f_1 = _e.value;
+                                if (!f_1.dbReadOnly && !f_1.isServerExpression) {
+                                    if (keys.includes(f_1.key)) {
+                                        newR[f_1.key] = f_1.valueConverter.toJson(data[f_1.key]);
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                        finally {
+                            try {
+                                if (_e && !_e.done && (_j = _d.return)) _j.call(_d);
+                            }
+                            finally { if (e_5) throw e_5.error; }
+                        }
+                        _g = (_f = collection).updateOne;
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 2: return [4 /*yield*/, _g.apply(_f, [_k.sent(), {
+                                $set: newR
+                            }])];
+                    case 3:
+                        r = _k.sent();
+                        return [2 /*return*/, this.find({ where: _1.Filter.fromEntityFilter(this.entity, resultFilter) }).then(function (y) { return y[0]; })];
+                }
+            });
+        });
+    };
+    MongoEntityDataProvider.prototype.delete = function (id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, e, collection, f, _b, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.collection()];
+                    case 1:
+                        _a = _d.sent(), e = _a.e, collection = _a.collection;
+                        f = new FilterConsumerBridgeToMongo(e);
+                        _1.Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+                        _c = (_b = collection).deleteOne;
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 2:
+                        _c.apply(_b, [_d.sent()]);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MongoEntityDataProvider.prototype.insert = function (data) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, collection, e, r, _b, _c, _d;
+            return tslib_1.__generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this.collection()];
+                    case 1:
+                        _a = _e.sent(), collection = _a.collection, e = _a.e;
+                        _c = (_b = collection).insertOne;
+                        return [4 /*yield*/, this.translateToJson(data, e)];
+                    case 2: return [4 /*yield*/, _c.apply(_b, [_e.sent()])];
+                    case 3:
+                        r = _e.sent();
+                        _d = this.translateFromJson;
+                        return [4 /*yield*/, collection.findOne({ _id: r.insertedId })];
+                    case 4: return [4 /*yield*/, _d.apply(this, [_e.sent(), e])];
+                    case 5: return [2 /*return*/, _e.sent()];
+                }
+            });
+        });
+    };
+    MongoEntityDataProvider.prototype.collection = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, collection;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(this.entity)];
+                    case 1:
+                        e = _a.sent();
+                        collection = this.db.collection(e.entityName);
+                        return [2 /*return*/, { e: e, collection: collection }];
+                }
+            });
+        });
+    };
+    return MongoEntityDataProvider;
+}());
+var FilterConsumerBridgeToMongo = /** @class */ (function () {
+    function FilterConsumerBridgeToMongo(nameProvider) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
         this.promises = [];
         this.result = [];
     }
-    async resolveWhere() {
-        while (this.promises.length > 0) {
-            let p = this.promises;
-            this.promises = [];
-            for (const pr of p) {
-                await pr;
-            }
-        }
-        if (this.result.length > 0)
-            return { $and: this.result.map(x => x()) };
-        else
-            return {};
-    }
-    custom(key, customItem) {
+    FilterConsumerBridgeToMongo.prototype.resolveWhere = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var p, p_1, p_1_1, pr, e_6_1;
+            var e_6, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(this.promises.length > 0)) return [3 /*break*/, 9];
+                        p = this.promises;
+                        this.promises = [];
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, 7, 8]);
+                        p_1 = (e_6 = void 0, tslib_1.__values(p)), p_1_1 = p_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!p_1_1.done) return [3 /*break*/, 5];
+                        pr = p_1_1.value;
+                        return [4 /*yield*/, pr];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        p_1_1 = p_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_6_1 = _b.sent();
+                        e_6 = { error: e_6_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        try {
+                            if (p_1_1 && !p_1_1.done && (_a = p_1.return)) _a.call(p_1);
+                        }
+                        finally { if (e_6) throw e_6.error; }
+                        return [7 /*endfinally*/];
+                    case 8: return [3 /*break*/, 0];
+                    case 9:
+                        if (this.result.length > 0)
+                            return [2 /*return*/, { $and: this.result.map(function (x) { return x(); }) }];
+                        else
+                            return [2 /*return*/, {}];
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    FilterConsumerBridgeToMongo.prototype.custom = function (key, customItem) {
         throw new Error("Custom filter should be translated before it gets here");
-    }
-    or(orElements) {
-        this.promises.push((async () => {
-            let result = [];
-            for (const element of orElements) {
-                let f = new FilterConsumerBridgeToMongo(this.nameProvider);
-                f._addWhere = false;
-                element.__applyToConsumer(f);
-                let where = await f.resolveWhere();
-                if (where?.$and?.length > 0) {
-                    result.push(where);
+    };
+    FilterConsumerBridgeToMongo.prototype.or = function (orElements) {
+        var _this = this;
+        this.promises.push((function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var result, orElements_1, orElements_1_1, element, f, where, e_7_1;
+            var e_7, _a;
+            var _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        result = [];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, 7, 8]);
+                        orElements_1 = tslib_1.__values(orElements), orElements_1_1 = orElements_1.next();
+                        _c.label = 2;
+                    case 2:
+                        if (!!orElements_1_1.done) return [3 /*break*/, 5];
+                        element = orElements_1_1.value;
+                        f = new FilterConsumerBridgeToMongo(this.nameProvider);
+                        f._addWhere = false;
+                        element.__applyToConsumer(f);
+                        return [4 /*yield*/, f.resolveWhere()];
+                    case 3:
+                        where = _c.sent();
+                        if (((_b = where === null || where === void 0 ? void 0 : where.$and) === null || _b === void 0 ? void 0 : _b.length) > 0) {
+                            result.push(where);
+                        }
+                        else
+                            return [2 /*return*/]; //since empty or is all rows;
+                        _c.label = 4;
+                    case 4:
+                        orElements_1_1 = orElements_1.next();
+                        return [3 /*break*/, 2];
+                    case 5: return [3 /*break*/, 8];
+                    case 6:
+                        e_7_1 = _c.sent();
+                        e_7 = { error: e_7_1 };
+                        return [3 /*break*/, 8];
+                    case 7:
+                        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; }
+                        return [7 /*endfinally*/];
+                    case 8:
+                        this.result.push(function () { return ({
+                            $or: result
+                        }); });
+                        return [2 /*return*/];
                 }
-                else
-                    return; //since empty or is all rows;
-            }
-            this.result.push(() => ({
-                $or: result
-            }));
-        })());
-    }
-    isNull(col) {
+            });
+        }); })());
+    };
+    FilterConsumerBridgeToMongo.prototype.isNull = function (col) {
         this.add(col, NULL, "$eq");
-    }
-    isNotNull(col) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isNotNull = function (col) {
         this.add(col, NULL, "$ne");
-    }
-    isIn(col, val) {
-        this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: {
-                $in: val.map(x => col.valueConverter.toDb(x))
-            }
-        }));
-    }
-    isEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isIn = function (col, val) {
+        var _this = this;
+        this.result.push(function () {
+            var _a;
+            return (_a = {},
+                _a[_this.nameProvider.nameOf(col)] = {
+                    $in: val.map(function (x) { return col.valueConverter.toDb(x); })
+                },
+                _a);
+        });
+    };
+    FilterConsumerBridgeToMongo.prototype.isEqualTo = function (col, val) {
         this.add(col, val, "$eq");
-    }
-    isDifferentFrom(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isDifferentFrom = function (col, val) {
         this.add(col, val, "$ne");
-    }
-    isGreaterOrEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isGreaterOrEqualTo = function (col, val) {
         this.add(col, val, "$gte");
-    }
-    isGreaterThan(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isGreaterThan = function (col, val) {
         this.add(col, val, "$gt");
-    }
-    isLessOrEqualTo(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isLessOrEqualTo = function (col, val) {
         this.add(col, val, "$lte");
-    }
-    isLessThan(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.isLessThan = function (col, val) {
         this.add(col, val, "$lt");
-    }
-    containsCaseInsensitive(col, val) {
+    };
+    FilterConsumerBridgeToMongo.prototype.containsCaseInsensitive = function (col, val) {
         throw "containsCaseInsensitive not yet implemented";
         // this.promises.push(col.getDbName().then(colName => {
         //     this.result.push(b => b.whereRaw(
         //         'lower (' + colName + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')"));
         // }));
-    }
-    add(col, val, operator) {
-        this.result.push(() => ({
-            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
-        }));
-    }
-    databaseCustom(databaseCustom) {
+    };
+    FilterConsumerBridgeToMongo.prototype.add = function (col, val, operator) {
+        var _this = this;
+        this.result.push(function () {
+            var _a, _b;
+            return (_a = {},
+                _a[_this.nameProvider.nameOf(col)] = (_b = {}, _b[operator] = isNull(val) ? val : col.valueConverter.toDb(val), _b),
+                _a);
+        });
+    };
+    FilterConsumerBridgeToMongo.prototype.databaseCustom = function (databaseCustom) {
         throw "error";
         //   this.promises.push((async () => {
         //     if (databaseCustom?.buildSql) {
@@ -216,5 +449,6 @@ class FilterConsumerBridgeToMongo {
         //       }
         //     }
         //   })());
-    }
-}
+    };
+    return FilterConsumerBridgeToMongo;
+}());

package/server/JsonEntityFileStorage.js

@@ -1,20 +1,25 @@
-import * as path from 'path';
-import * as fs from 'fs';
-export class JsonEntityFileStorage {
-    constructor(folderPath) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonEntityFileStorage = void 0;
+var path = require("path");
+var fs = require("fs");
+var JsonEntityFileStorage = /** @class */ (function () {
+    function JsonEntityFileStorage(folderPath) {
         this.folderPath = folderPath;
     }
-    getItem(entityDbName) {
-        let fn = path.join(this.folderPath, entityDbName) + '.json';
+    JsonEntityFileStorage.prototype.getItem = function (entityDbName) {
+        var fn = path.join(this.folderPath, entityDbName) + '.json';
         if (fs.existsSync(fn)) {
             return fs.readFileSync(fn).toString();
         }
         return undefined;
-    }
-    setItem(entityDbName, json) {
+    };
+    JsonEntityFileStorage.prototype.setItem = function (entityDbName, json) {
         if (!fs.existsSync(this.folderPath)) {
             fs.mkdirSync(this.folderPath);
         }
         return fs.writeFileSync(path.join(this.folderPath, entityDbName) + '.json', json);
-    }
-}
+    };
+    return JsonEntityFileStorage;
+}());
+exports.JsonEntityFileStorage = JsonEntityFileStorage;