remult 0.14.4 → 0.14.5

package/remult-mongo.js

@@ -1,444 +1,211 @@
-"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) {
+import { CompoundIdField, Filter } from '.';
+import { getDbNameProvider } from './src/filter/filter-consumer-bridge-to-sql-request';
+export class MongoDataProvider {
+    constructor(db, client) {
         this.db = db;
         this.client = client;
     }
-    MongoDataProvider.prototype.getEntityDataProvider = function (entity) {
+    getEntityDataProvider(entity) {
         return new MongoEntityDataProvider(this.db, entity);
-    };
-    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" };
+    }
+    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" };
 function isNull(x) {
-    return (x === null || x === void 0 ? void 0 : x.$null) === NULL.$null;
+    return x?.$null === NULL.$null;
 }
-var MongoEntityDataProvider = /** @class */ (function () {
-    function MongoEntityDataProvider(db, entity) {
+class MongoEntityDataProvider {
+    constructor(db, entity) {
         this.db = db;
         this.entity = entity;
     }
-    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;
-            }
+    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;
         }
-        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;
+    }
+    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;
-    };
-    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;
+    }
+    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;
             }
         }
-        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) {
+            op.sort = {};
+            for (const s of options.orderBy.Segments) {
+                op.sort[e.nameOf(s.field)] = s.isDescending ? -1 : 1;
             }
-            finally { if (e_2) throw e_2.error; }
         }
-        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()];
-                }
-            });
-        });
-    };
-    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 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);
+            }
+        }
+        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]);
                 }
-            });
+            }
+        }
+        let r = await collection.updateOne(await f.resolveWhere(), {
+            $set: newR
         });
-    };
-    return MongoEntityDataProvider;
-}());
-var FilterConsumerBridgeToMongo = /** @class */ (function () {
-    function FilterConsumerBridgeToMongo(nameProvider) {
+        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) {
         this.nameProvider = nameProvider;
         this._addWhere = true;
         this.promises = [];
         this.result = [];
     }
-    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) {
+    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) {
         throw new Error("Custom filter should be translated before it gets here");
-    };
-    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*/];
+    }
+    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.isNull = function (col) {
+                else
+                    return; //since empty or is all rows;
+            }
+            this.result.push(() => ({
+                $or: result
+            }));
+        })());
+    }
+    isNull(col) {
         this.add(col, NULL, "$eq");
-    };
-    FilterConsumerBridgeToMongo.prototype.isNotNull = function (col) {
+    }
+    isNotNull(col) {
         this.add(col, NULL, "$ne");
-    };
-    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) {
+    }
+    isIn(col, val) {
+        this.result.push(() => ({
+            [this.nameProvider.nameOf(col)]: {
+                $in: val.map(x => col.valueConverter.toDb(x))
+            }
+        }));
+    }
+    isEqualTo(col, val) {
         this.add(col, val, "$eq");
-    };
-    FilterConsumerBridgeToMongo.prototype.isDifferentFrom = function (col, val) {
+    }
+    isDifferentFrom(col, val) {
         this.add(col, val, "$ne");
-    };
-    FilterConsumerBridgeToMongo.prototype.isGreaterOrEqualTo = function (col, val) {
+    }
+    isGreaterOrEqualTo(col, val) {
         this.add(col, val, "$gte");
-    };
-    FilterConsumerBridgeToMongo.prototype.isGreaterThan = function (col, val) {
+    }
+    isGreaterThan(col, val) {
         this.add(col, val, "$gt");
-    };
-    FilterConsumerBridgeToMongo.prototype.isLessOrEqualTo = function (col, val) {
+    }
+    isLessOrEqualTo(col, val) {
         this.add(col, val, "$lte");
-    };
-    FilterConsumerBridgeToMongo.prototype.isLessThan = function (col, val) {
+    }
+    isLessThan(col, val) {
         this.add(col, val, "$lt");
-    };
-    FilterConsumerBridgeToMongo.prototype.containsCaseInsensitive = function (col, val) {
+    }
+    containsCaseInsensitive(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, '\'\'') + "%')"));
         // }));
-    };
-    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) {
+    }
+    add(col, val, operator) {
+        this.result.push(() => ({
+            [this.nameProvider.nameOf(col)]: { [operator]: isNull(val) ? val : col.valueConverter.toDb(val) }
+        }));
+    }
+    databaseCustom(databaseCustom) {
         throw "error";
         //   this.promises.push((async () => {
         //     if (databaseCustom?.buildSql) {
@@ -449,6 +216,5 @@ var FilterConsumerBridgeToMongo = /** @class */ (function () {
         //       }
         //     }
         //   })());
-    };
-    return FilterConsumerBridgeToMongo;
-}());
+    }
+}

package/server/JsonEntityFileStorage.js

@@ -1,25 +1,20 @@
-"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) {
+import * as path from 'path';
+import * as fs from 'fs';
+export class JsonEntityFileStorage {
+    constructor(folderPath) {
         this.folderPath = folderPath;
     }
-    JsonEntityFileStorage.prototype.getItem = function (entityDbName) {
-        var fn = path.join(this.folderPath, entityDbName) + '.json';
+    getItem(entityDbName) {
+        let fn = path.join(this.folderPath, entityDbName) + '.json';
         if (fs.existsSync(fn)) {
             return fs.readFileSync(fn).toString();
         }
         return undefined;
-    };
-    JsonEntityFileStorage.prototype.setItem = function (entityDbName, json) {
+    }
+    setItem(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;
+    }
+}