apexify.js 2.4.4 → 3.0.1

package/lib/database/NanoDB.js

@@ -1,1341 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NanoDb = void 0;
-var events_1 = require("events");
-var utils_1 = require("./utils");
-var fs = require("fs");
-var fs_1 = require("fs");
-var zlib = require("zlib");
-var archiver = require("archiver");
-var path = require("path");
-var crypto = require("crypto");
-var NanoDb = /** @class */ (function (_super) {
-    __extends(NanoDb, _super);
-    function NanoDb(filePath) {
-        var _this = _super.call(this) || this;
-        _this.indexes = new Map();
-        if (!filePath)
-            throw new Error("Error: filePath is required. Usage: new NanoDb('./data.json')");
-        _this.filePath = filePath;
-        _this.dataPromise = _this.loadData();
-        return _this;
-    }
-    NanoDb.prototype.loadData = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, err_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, fs_1.promises.readFile(this.filePath, 'utf8')];
-                    case 1:
-                        data = _a.sent();
-                        return [2 /*return*/, JSON.parse(data)];
-                    case 2:
-                        err_1 = _a.sent();
-                        return [2 /*return*/, []];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.addOne = function (newData, options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var result, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, (0, utils_1.saveData)(this.filePath, newData, options && options.uniqueKeys)];
-                    case 1:
-                        result = _a.sent();
-                        if (result.success) {
-                            this.emit('dataInserted', newData);
-                        }
-                        this.dataPromise = this.loadData();
-                        return [2 /*return*/, result];
-                    case 2:
-                        error_1 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error saving data',
-                                errorMessage: error_1.message,
-                                documentsCount: 0,
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.displayData = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, filteredData, sortBy_1, sortOrder_1, page, pageSize, startIndex, endIndex, paginatedData, error_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        filteredData = data;
-                        if (options === null || options === void 0 ? void 0 : options.filters) {
-                            filteredData = data.filter(function (document) { return (0, utils_1.matchesFilterQuery)(document, options.filters); });
-                        }
-                        sortBy_1 = options === null || options === void 0 ? void 0 : options.sortBy;
-                        sortOrder_1 = (options === null || options === void 0 ? void 0 : options.sortOrder) === 'desc' ? -1 : 1;
-                        if (sortBy_1) {
-                            filteredData.sort(function (a, b) { return (a[sortBy_1] > b[sortBy_1] ? sortOrder_1 : -sortOrder_1); });
-                        }
-                        page = (options === null || options === void 0 ? void 0 : options.page) || 1;
-                        pageSize = (options === null || options === void 0 ? void 0 : options.pageSize) || 10;
-                        startIndex = (page - 1) * pageSize;
-                        endIndex = startIndex + pageSize;
-                        paginatedData = filteredData.slice(startIndex, endIndex);
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data displayed successfully',
-                                documentsCount: paginatedData.length,
-                                displayedResults: paginatedData,
-                            }];
-                    case 2:
-                        error_2 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error displaying data',
-                                errorMessage: error_2.message,
-                                documentsCount: 0,
-                                displayedResults: [],
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.removeOne = function (filterQuery, removeFilter) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, result, error_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        result = (0, utils_1.removeFields)(data, filterQuery, removeFilter);
-                        return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, JSON.stringify(result, null, 2), 'utf8')];
-                    case 2:
-                        _a.sent();
-                        this.emit('dataRemoved', {
-                            success: true,
-                            message: 'Successfully removed the specified field(s) from a single document.',
-                            documentsCount: result.length,
-                        });
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Successfully removed the specified field(s) from a single document.',
-                                documentsCount: result.length,
-                            }];
-                    case 3:
-                        error_3 = _a.sent();
-                        this.emit('dataRemoveError', {
-                            success: false,
-                            message: 'Error removing field(s) from a single document.',
-                            errorMessage: error_3.message,
-                            documentsCount: 0,
-                        });
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error removing field(s) from a single document.',
-                                errorMessage: error_3.message,
-                                documentsCount: 0,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.removeDoc = function (filterQuery) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, indexToRemove, error_4;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 5, , 6]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        indexToRemove = void 0;
-                        if (Object.keys(filterQuery).length === 0) {
-                            indexToRemove = 0;
-                        }
-                        else {
-                            indexToRemove = data.findIndex(function (document) { return (0, utils_1.matchesFilterQuery)(document, filterQuery); });
-                        }
-                        if (!(indexToRemove !== -1)) return [3 /*break*/, 3];
-                        data.splice(indexToRemove, 1);
-                        return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, JSON.stringify(data, null, 2), 'utf8')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Successfully removed the specified document.',
-                                documentsCount: data.length,
-                            }];
-                    case 3: return [2 /*return*/, {
-                            success: false,
-                            message: 'Document not found for removal.',
-                            documentsCount: data.length,
-                            fileSizeInBytes: 0,
-                        }];
-                    case 4: return [3 /*break*/, 6];
-                    case 5:
-                        error_4 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error removing document.',
-                                errorMessage: error_4.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.updateData = function (filterQuery, updateOptions, uniqueKeys, upsert) {
-        if (uniqueKeys === void 0) { uniqueKeys = []; }
-        if (upsert === void 0) { upsert = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var data, existingDocumentsWithUniqueKeys, indexToUpdate, updatedDocument, newDocument, error_5;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 6, , 7]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        if (uniqueKeys.length > 0) {
-                            existingDocumentsWithUniqueKeys = data.filter(function (document) {
-                                return uniqueKeys.every(function (key) {
-                                    return document.unique && document.unique[key] === updateOptions[key];
-                                });
-                            });
-                            if (existingDocumentsWithUniqueKeys.length > 0) {
-                                this.emit('dataUpdateError', {
-                                    success: false,
-                                    message: "Update violates uniqueness for specified keys: ".concat(uniqueKeys.join(', '), "."),
-                                    documentsCount: data.length,
-                                    fileSizeInBytes: 0,
-                                });
-                                return [2 /*return*/, {
-                                        success: false,
-                                        message: "Update violates uniqueness for specified keys: ".concat(uniqueKeys.join(', '), "."),
-                                        documentsCount: data.length,
-                                        fileSizeInBytes: 0,
-                                    }];
-                            }
-                        }
-                        indexToUpdate = data.findIndex(function (document) { return (0, utils_1.matchesFilterQuery)(document, filterQuery); });
-                        if (!(indexToUpdate !== -1)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, (0, utils_1.updateOption)(data[indexToUpdate], updateOptions)];
-                    case 2:
-                        updatedDocument = _a.sent();
-                        data[indexToUpdate] = updatedDocument;
-                        this.emit('dataUpdated', {
-                            success: true,
-                            message: 'Successfully updated the specified document.',
-                            documentsCount: data.length,
-                            fileSizeInBytes: 0,
-                        });
-                        return [3 /*break*/, 4];
-                    case 3:
-                        if (upsert) {
-                            newDocument = __assign(__assign({}, filterQuery), updateOptions);
-                            data.push(newDocument);
-                            this.emit('dataInserted', {
-                                success: true,
-                                message: 'Successfully inserted the specified document.',
-                                documentsCount: data.length,
-                                fileSizeInBytes: 0,
-                            });
-                        }
-                        else {
-                            this.emit('dataUpdateError', {
-                                success: false,
-                                message: 'Document not found for update.',
-                                documentsCount: data.length,
-                                fileSizeInBytes: 0,
-                            });
-                            return [2 /*return*/, {
-                                    success: false,
-                                    message: 'Document not found for update.',
-                                    documentsCount: data.length,
-                                    fileSizeInBytes: 0,
-                                }];
-                        }
-                        _a.label = 4;
-                    case 4: return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, JSON.stringify(data, null, 2), 'utf8')];
-                    case 5:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Successfully updated/inserted the specified document.',
-                                documentsCount: data.length,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 6:
-                        error_5 = _a.sent();
-                        this.emit('dataUpdateError', {
-                            success: false,
-                            message: 'Error updating/inserting document.',
-                            errorMessage: error_5.message,
-                            documentsCount: 0,
-                            fileSizeInBytes: 0,
-                        });
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error updating/inserting document.',
-                                errorMessage: error_5.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.findData = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, foundResult, _i, data_1, document_1, isMatch, key, documentValue, queryValue, error_6;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        foundResult = null;
-                        for (_i = 0, data_1 = data; _i < data_1.length; _i++) {
-                            document_1 = data_1[_i];
-                            isMatch = true;
-                            for (key in query) {
-                                documentValue = String(document_1[key]).toLowerCase();
-                                queryValue = String(query[key]).toLowerCase();
-                                if (query[key] !== 'any' && documentValue !== queryValue) {
-                                    isMatch = false;
-                                    break;
-                                }
-                            }
-                            if (isMatch) {
-                                foundResult = __assign({}, document_1);
-                                break;
-                            }
-                        }
-                        if (!foundResult) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    message: 'No data found matching the search.',
-                                    documentsCount: 0,
-                                    foundResults: null,
-                                    fileSizeInBytes: 0,
-                                }];
-                        }
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data found successfully',
-                                documentsCount: 1,
-                                foundResults: [foundResult],
-                                fileSizeInBytes: 0,
-                            }];
-                    case 2:
-                        error_6 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error finding data',
-                                errorMessage: error_6.message,
-                                documentsCount: 0,
-                                foundResults: [],
-                                fileSizeInBytes: 0,
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.updateMany = function (filterQuery, updateOptions, upsert) {
-        if (upsert === void 0) { upsert = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var data, matchingDocuments, _loop_1, _i, matchingDocuments_1, matchingDocument, newDocument, error_7;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 9, , 10]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        matchingDocuments = data.filter(function (document) { return (0, utils_1.matchesFilterQuery)(document, filterQuery); });
-                        if (!(matchingDocuments.length > 0)) return [3 /*break*/, 6];
-                        _loop_1 = function (matchingDocument) {
-                            var indexToUpdate, updatedDocument;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        indexToUpdate = data.findIndex(function (doc) { return doc === matchingDocument; });
-                                        return [4 /*yield*/, (0, utils_1.updateOption)(matchingDocument, updateOptions)];
-                                    case 1:
-                                        updatedDocument = _b.sent();
-                                        data[indexToUpdate] = updatedDocument;
-                                        return [2 /*return*/];
-                                }
-                            });
-                        };
-                        _i = 0, matchingDocuments_1 = matchingDocuments;
-                        _a.label = 2;
-                    case 2:
-                        if (!(_i < matchingDocuments_1.length)) return [3 /*break*/, 5];
-                        matchingDocument = matchingDocuments_1[_i];
-                        return [5 /*yield**/, _loop_1(matchingDocument)];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        _i++;
-                        return [3 /*break*/, 2];
-                    case 5:
-                        this.emit('dataUpdated', {
-                            filterQuery: filterQuery,
-                            updateOptions: updateOptions,
-                            updatedCount: matchingDocuments.length,
-                        });
-                        return [3 /*break*/, 7];
-                    case 6:
-                        if (upsert) {
-                            newDocument = __assign(__assign({}, filterQuery), updateOptions);
-                            data.push(newDocument);
-                        }
-                        else {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    message: 'No documents found for update.',
-                                    documentsCount: data.length,
-                                    fileSizeInBytes: 0,
-                                }];
-                        }
-                        _a.label = 7;
-                    case 7: return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, JSON.stringify(data, null, 2), 'utf8')];
-                    case 8:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Successfully updated/inserted the specified documents.',
-                                documentsCount: data.length,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 9:
-                        error_7 = _a.sent();
-                        this.emit('dataUpdateError', {
-                            error: error_7,
-                            methodName: 'updateMany',
-                        });
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error updating/inserting documents.',
-                                errorMessage: error_7.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 10: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.drop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var error_8;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, '[]', 'utf8')];
-                    case 1:
-                        _a.sent();
-                        this.dataPromise = this.loadData();
-                        this.emit('dataDropped', {
-                            methodName: 'drop',
-                        });
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data dropped successfully',
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 2:
-                        error_8 = _a.sent();
-                        this.emit('dataUpdateError', {
-                            error: error_8,
-                            methodName: 'drop',
-                        });
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error dropping data',
-                                errorMessage: error_8.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.countDoc = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, documentCount, error_9;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        documentCount = data.length;
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Document count retrieved successfully.',
-                                documentsCount: documentCount,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 2:
-                        error_9 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error counting documents.',
-                                errorMessage: error_9.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.dataSize = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var fileStats, fileSizeInBytes, error_10;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, fs_1.promises.stat(this.filePath)];
-                    case 1:
-                        fileStats = _a.sent();
-                        fileSizeInBytes = fileStats.size;
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data file size retrieved successfully.',
-                                fileSizeInBytes: fileSizeInBytes,
-                                documentsCount: 0,
-                            }];
-                    case 2:
-                        error_10 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error retrieving data file size.',
-                                errorMessage: error_10.message,
-                                fileSizeInBytes: 0,
-                                documentsCount: 0,
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.transferData = function (destinationFilePath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sourceData, destinationExists, destinationData, _a, _b, mergedData, error_11;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _c.trys.push([0, 8, , 9]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        sourceData = _c.sent();
-                        return [4 /*yield*/, this.fileExists(destinationFilePath)];
-                    case 2:
-                        destinationExists = _c.sent();
-                        destinationData = [];
-                        if (!destinationExists) return [3 /*break*/, 4];
-                        _b = (_a = JSON).parse;
-                        return [4 /*yield*/, fs_1.promises.readFile(destinationFilePath, 'utf8')];
-                    case 3:
-                        destinationData = _b.apply(_a, [_c.sent()]);
-                        return [3 /*break*/, 6];
-                    case 4: return [4 /*yield*/, fs_1.promises.writeFile(destinationFilePath, '[]', 'utf8')];
-                    case 5:
-                        _c.sent();
-                        _c.label = 6;
-                    case 6:
-                        mergedData = __spreadArray(__spreadArray([], destinationData, true), sourceData, true);
-                        return [4 /*yield*/, fs_1.promises.writeFile(destinationFilePath, JSON.stringify(mergedData, null, 2), 'utf8')];
-                    case 7:
-                        _c.sent();
-                        this.emit('dataTransferred', {
-                            success: true,
-                            message: 'Data transferred and added to existing data successfully.',
-                            documentsCount: mergedData.length,
-                            destinationFilePath: destinationFilePath,
-                            fileSizeInBytes: 0,
-                        });
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data transferred and added to existing data successfully.',
-                                documentsCount: mergedData.length,
-                                destinationFilePath: destinationFilePath,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 8:
-                        error_11 = _c.sent();
-                        this.emit('transferError', {
-                            success: false,
-                            message: 'Error transferring and adding data.',
-                            errorMessage: error_11.message,
-                            documentsCount: 0,
-                            fileSizeInBytes: 0,
-                        });
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error transferring and adding data.',
-                                errorMessage: error_11.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 9: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.fileExists = function (filePath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, fs_1.promises.access(filePath)];
-                    case 1:
-                        _b.sent();
-                        return [2 /*return*/, true];
-                    case 2:
-                        _a = _b.sent();
-                        return [2 /*return*/, false];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.distinct = function (field) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, distinctValues, valueSet, _i, data_2, document_2, fieldValue, error_12;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        distinctValues = [];
-                        valueSet = new Set();
-                        for (_i = 0, data_2 = data; _i < data_2.length; _i++) {
-                            document_2 = data_2[_i];
-                            fieldValue = document_2[field];
-                            if (fieldValue === undefined || fieldValue === null) {
-                                return [2 /*return*/, {
-                                        success: false,
-                                        message: "Error retrieving distinct values. Field with the name '".concat(field, "' not found in some documents."),
-                                        documentsCount: 0,
-                                        distinctValues: [],
-                                        fileSizeInBytes: 0,
-                                    }];
-                            }
-                            if (!valueSet.has(fieldValue)) {
-                                valueSet.add(fieldValue);
-                                distinctValues.push(fieldValue);
-                            }
-                        }
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Distinct values retrieved successfully.',
-                                documentsCount: distinctValues.length,
-                                distinctValues: distinctValues,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 2:
-                        error_12 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error retrieving distinct values.',
-                                errorMessage: error_12.message,
-                                documentsCount: 0,
-                                distinctValues: [],
-                                fileSizeInBytes: 0,
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.indexData = function (data) {
-        for (var field in data) {
-            if (!this.indexes.has(field)) {
-                this.indexes.set(field, new Map());
-            }
-            var fieldValue = data[field];
-            if (!this.indexes.get(field).has(fieldValue)) {
-                this.indexes.get(field).set(fieldValue, []);
-            }
-            this.indexes.get(field).get(fieldValue).push(data);
-        }
-    };
-    NanoDb.prototype.backup = function (filePathToJsonData, typeOfCompression, options) {
-        if (options === void 0) { options = {}; }
-        var compressionTypes = ['zip', 'json', 'gzip', 'txt'];
-        if (!compressionTypes.includes(typeOfCompression)) {
-            throw new Error('Invalid compression type');
-        }
-        var outputPath = options.outputPath, _a = options.encrypted, encrypted = _a === void 0 ? false : _a, key = options.key;
-        if (encrypted && !key) {
-            throw new Error('Encryption key is required for encryption');
-        }
-        var jsonData = fs.readFileSync(filePathToJsonData, 'utf-8');
-        var encryptedData = jsonData;
-        if (encrypted) {
-            var algorithm = 'aes-256-cbc';
-            var iv = crypto.randomBytes(16);
-            var cipher = crypto.createCipheriv(algorithm, Buffer.from(key), iv);
-            encryptedData = JSON.stringify({
-                iv: iv.toString('hex'),
-                content: cipher.update(jsonData, 'utf8', 'hex') + cipher.final('hex'),
-            });
-        }
-        if (typeOfCompression === 'zip') {
-            this.createZipBackup(encryptedData, outputPath);
-        }
-        else if (typeOfCompression === 'gzip') {
-            this.createGzipBackup(jsonData, encryptedData, outputPath, encrypted, key);
-        }
-        else if (typeOfCompression === 'txt' || typeOfCompression === 'json') {
-            this.createTextOrJsonBackup(encryptedData, outputPath);
-        }
-        else {
-            throw new Error('Unsupported compression format');
-        }
-    };
-    NanoDb.prototype.createZipBackup = function (data, outputPath) {
-        return new Promise(function (resolve, reject) {
-            try {
-                var archive = archiver('zip', { zlib: { level: 9 } });
-                var outputStream = outputPath ? fs.createWriteStream(outputPath) : process.stdout;
-                archive.pipe(outputStream);
-                archive.append(data, { name: 'backup.json' });
-                archive.finalize();
-                outputStream.on('close', function () {
-                    resolve({
-                        success: true,
-                        message: "Backup created successfully: ".concat(outputPath || 'stdout'),
-                        documentsCount: null
-                    });
-                });
-            }
-            catch (error) {
-                console.error(error.message);
-                reject({
-                    success: false,
-                    message: 'Error performing backup.',
-                    errorMessage: error.message,
-                });
-            }
-        });
-    };
-    NanoDb.prototype.createGzipBackup = function (jsonData, encryptedData, outputPath, encrypted, key) {
-        return new Promise(function (resolve, reject) {
-            try {
-                var gzip = zlib.createGzip({ level: 9 });
-                var cipher = encrypted
-                    ? crypto.createCipheriv('aes-256-cbc', Buffer.from(key), crypto.randomBytes(16))
-                    : null;
-                var inputStream = encrypted
-                    ? fs.createReadStream('./data2.json').pipe(cipher)
-                    : fs.createReadStream(Buffer.from(jsonData, 'utf-8'));
-                var outputStream = outputPath ? fs.createWriteStream(outputPath) : process.stdout;
-                var pipeline = inputStream.pipe(gzip).pipe(outputStream);
-                pipeline.on('finish', function () {
-                    resolve({
-                        success: true,
-                        message: "Backup created successfully: ".concat(outputPath || 'stdout'),
-                        documentsCount: null
-                    });
-                });
-            }
-            catch (error) {
-                console.error(error.message);
-                reject({
-                    success: false,
-                    message: 'Error performing backup.',
-                    errorMessage: error.message,
-                });
-            }
-        });
-    };
-    NanoDb.prototype.createTextOrJsonBackup = function (encryptedData, outputPath) {
-        return new Promise(function (resolve, reject) {
-            try {
-                var dataToWrite = encryptedData;
-                if (outputPath) {
-                    fs.writeFileSync(outputPath, dataToWrite, 'utf-8');
-                    resolve({
-                        success: true,
-                        message: "Backup created successfully: ".concat(outputPath || 'stdout'),
-                        documentsCount: null
-                    });
-                }
-                else {
-                    resolve({
-                        success: false,
-                        message: "No output path specified. Backup content: ".concat(dataToWrite),
-                        documentsCount: null
-                    });
-                }
-            }
-            catch (error) {
-                console.error(error.message);
-                reject({
-                    success: false,
-                    message: 'Error performing backup.',
-                    errorMessage: error.message,
-                });
-            }
-        });
-    };
-    NanoDb.prototype.decrypt = function (encryptedData, decryptKey) {
-        if (!decryptKey) {
-            throw new Error('Encryption key is required for decryption.');
-        }
-        var algorithm = 'aes-256-cbc';
-        var key = Buffer.from(decryptKey, 'utf8');
-        var decipher = crypto.createDecipheriv(algorithm, key, Buffer.alloc(16));
-        var decrypted = decipher.update(encryptedData, 'hex', 'utf8');
-        decrypted += decipher.final('utf8');
-        return decrypted;
-    };
-    NanoDb.prototype.nanoSize = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var projectRoot, totalSize, fileSizes, files, _i, files_1, file, filePath, stats, subFiles, _a, subFiles_1, subFile, subFilePath, subFileStats, subFileSize, fileSize, error_13;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        projectRoot = process.cwd();
-                        totalSize = 0;
-                        fileSizes = {};
-                        _b.label = 1;
-                    case 1:
-                        _b.trys.push([1, 13, , 14]);
-                        return [4 /*yield*/, fs_1.promises.readdir(projectRoot)];
-                    case 2:
-                        files = _b.sent();
-                        _i = 0, files_1 = files;
-                        _b.label = 3;
-                    case 3:
-                        if (!(_i < files_1.length)) return [3 /*break*/, 12];
-                        file = files_1[_i];
-                        filePath = path.join(projectRoot, file);
-                        return [4 /*yield*/, fs_1.promises.stat(filePath)];
-                    case 4:
-                        stats = _b.sent();
-                        if (!(stats.isDirectory() && !filePath.includes('node_modules'))) return [3 /*break*/, 10];
-                        return [4 /*yield*/, fs_1.promises.readdir(filePath)];
-                    case 5:
-                        subFiles = _b.sent();
-                        _a = 0, subFiles_1 = subFiles;
-                        _b.label = 6;
-                    case 6:
-                        if (!(_a < subFiles_1.length)) return [3 /*break*/, 9];
-                        subFile = subFiles_1[_a];
-                        subFilePath = path.join(filePath, subFile);
-                        return [4 /*yield*/, fs_1.promises.stat(subFilePath)];
-                    case 7:
-                        subFileStats = _b.sent();
-                        if (subFileStats.isFile() && path.extname(subFilePath).toLowerCase() === '.json') {
-                            subFileSize = subFileStats.size;
-                            totalSize += subFileSize;
-                            fileSizes[subFile] = subFileSize;
-                        }
-                        _b.label = 8;
-                    case 8:
-                        _a++;
-                        return [3 /*break*/, 6];
-                    case 9: return [3 /*break*/, 11];
-                    case 10:
-                        if (stats.isFile() && path.extname(filePath).toLowerCase() === '.json') {
-                            fileSize = stats.size;
-                            totalSize += fileSize;
-                            fileSizes[file] = fileSize;
-                        }
-                        _b.label = 11;
-                    case 11:
-                        _i++;
-                        return [3 /*break*/, 3];
-                    case 12: return [2 /*return*/, { totalSize: totalSize, fileSizes: fileSizes }];
-                    case 13:
-                        error_13 = _b.sent();
-                        console.error('Error calculating total size:', error_13.message);
-                        return [2 /*return*/, { totalSize: 0, fileSizes: {} }];
-                    case 14: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.replicate = function (sourceFilePath, targetFilePath) {
-        try {
-            var sourceData = fs.readFileSync(sourceFilePath, 'utf8');
-            var jsonData = JSON.parse(sourceData);
-            fs.writeFileSync(targetFilePath, JSON.stringify(jsonData, null, 2), 'utf8');
-            var documentCount = jsonData.length;
-            var fileSize = Buffer.from(JSON.stringify(jsonData)).length;
-            return {
-                success: true,
-                message: 'Data replicated successfully.',
-                documentCount: documentCount,
-                fileSize: fileSize,
-            };
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                console.error('Target file not found.');
-                return {
-                    success: false,
-                    message: 'Target file not found.',
-                };
-            }
-            else {
-                console.error(error.message);
-                return {
-                    success: false,
-                    message: "Error replicating data: ".concat(error.message),
-                };
-            }
-        }
-    };
-    NanoDb.prototype.aggregate = function (pipeline) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data_3, result, error_14;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data_3 = _a.sent();
-                        result = pipeline.reduce(function (acc, stage) {
-                            if (stage.$match) {
-                                acc = acc.filter(function (document) { return (0, utils_1.matchesFilterQuery)(document, stage.$match); });
-                            }
-                            else if (stage.$group) {
-                                var groupedData_1 = new Map();
-                                var key_1 = stage.$group._id;
-                                acc.forEach(function (document) {
-                                    var keyValue = String(document[key_1]);
-                                    if (!groupedData_1.has(keyValue)) {
-                                        groupedData_1.set(keyValue, []);
-                                    }
-                                    groupedData_1.get(keyValue).push(document);
-                                });
-                                acc = Array.from(groupedData_1.values(), function (value) {
-                                    var _a;
-                                    return (_a = {}, _a[key_1] = value, _a);
-                                });
-                            }
-                            else if (stage.$project) {
-                                acc = acc.map(function (document) {
-                                    var projectedDocument = {};
-                                    for (var field in stage.$project) {
-                                        var fieldPath = stage.$project[field];
-                                        var fieldValue = fieldPath.split('.').reduce(function (obj, key) { return obj[key]; }, document);
-                                        projectedDocument[field] = fieldValue;
-                                    }
-                                    return projectedDocument;
-                                });
-                            }
-                            else if (stage.$sort) {
-                                var sortBy_2 = stage.$sort.field;
-                                var sortOrder_2 = stage.$sort.order === 'desc' ? -1 : 1;
-                                acc.sort(function (a, b) { return (a[sortBy_2] > b[sortBy_2] ? sortOrder_2 : -sortOrder_2); });
-                            }
-                            else if (stage.$skip) {
-                                var skipCount = stage.$skip;
-                                acc = acc.slice(skipCount);
-                            }
-                            else if (stage.$limit) {
-                                var limitCount = stage.$limit;
-                                acc = acc.slice(0, limitCount);
-                            }
-                            else if (stage.$unwind) {
-                                var unwindField_1 = stage.$unwind;
-                                acc = acc.flatMap(function (document) {
-                                    var unwindArray = document[unwindField_1] || [];
-                                    return unwindArray.map(function (arrayElement) {
-                                        var _a;
-                                        return (__assign(__assign({}, document), (_a = {}, _a[unwindField_1] = arrayElement, _a)));
-                                    });
-                                });
-                            }
-                            else if (stage.$lookup) {
-                                var localField_1 = stage.$lookup.localField;
-                                var foreignField_1 = stage.$lookup.foreignField;
-                                var asField_1 = stage.$lookup.as;
-                                acc = acc.map(function (document) {
-                                    var _a;
-                                    var lookupValue = document[localField_1];
-                                    var matchingDocuments = data_3.filter(function (lookupDoc) { return lookupDoc[foreignField_1] === lookupValue; });
-                                    return __assign(__assign({}, document), (_a = {}, _a[asField_1] = matchingDocuments, _a));
-                                });
-                            }
-                            else if (stage.$addFields) {
-                                var newFields_1 = stage.$addFields;
-                                acc = acc.map(function (document) {
-                                    for (var field in newFields_1) {
-                                        document[field] = newFields_1[field];
-                                    }
-                                    return document;
-                                });
-                            }
-                            else if (stage.$replaceRoot) {
-                                var newRootField_1 = stage.$replaceRoot.newRoot;
-                                acc = acc.map(function (document) { return document[newRootField_1]; });
-                            }
-                            else if (stage.$count) {
-                                acc = [{ count: acc.length }];
-                            }
-                            return acc;
-                        }, data_3);
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Aggregation completed successfully.',
-                                documentsCount: result.length,
-                                aggregatedResults: result,
-                            }];
-                    case 2:
-                        error_14 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error performing aggregation.',
-                                errorMessage: error_14.message,
-                                documentsCount: 0,
-                                aggregatedResults: [],
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.encryptData = function (encryptKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, algorithm, iv, cipher, encryptedData, encryptedDataObject, error_15;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        algorithm = 'aes-256-cbc';
-                        iv = crypto.randomBytes(16);
-                        cipher = crypto.createCipheriv(algorithm, Buffer.from(encryptKey), iv);
-                        encryptedData = cipher.update(JSON.stringify(data), 'utf8', 'hex');
-                        encryptedData += cipher.final('hex');
-                        encryptedDataObject = {
-                            iv: iv.toString('hex'),
-                            encryptedData: encryptedData,
-                        };
-                        this.dataPromise = Promise.resolve([encryptedDataObject]);
-                        return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, JSON.stringify([encryptedDataObject], null, 2), 'utf8')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data encrypted and written to file successfully.',
-                                documentsCount: data.length,
-                            }];
-                    case 3:
-                        error_15 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error encrypting and writing data to file.',
-                                documentsCount: 0,
-                                errorMessage: error_15.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.decryptData = function (encryptKey) {
-        return __awaiter(this, void 0, void 0, function () {
-            var encryptedDataArray, encryptedDataObject, algorithm, decipher, decryptedData, error_16;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, fs_1.promises.readFile(this.filePath, 'utf8')];
-                    case 1:
-                        encryptedDataArray = _a.sent();
-                        encryptedDataObject = JSON.parse(encryptedDataArray)[0];
-                        algorithm = 'aes-256-cbc';
-                        decipher = crypto.createDecipheriv(algorithm, Buffer.from(encryptKey), Buffer.from(encryptedDataObject.iv, 'hex'));
-                        decryptedData = decipher.update(encryptedDataObject.encryptedData, 'hex', 'utf8');
-                        decryptedData += decipher.final('utf8');
-                        this.dataPromise = Promise.resolve(JSON.parse(decryptedData));
-                        return [4 /*yield*/, fs_1.promises.writeFile(this.filePath, JSON.stringify(JSON.parse(decryptedData), null, 2), 'utf8')];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Data decrypted and written to file successfully.',
-                                documentsCount: JSON.parse(decryptedData).length,
-                            }];
-                    case 3:
-                        error_16 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error decrypting data.',
-                                documentsCount: 0,
-                                errorMessage: error_16.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.fullTextSearch = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, foundResults, error_17;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        foundResults = data.filter(function (document) {
-                            for (var key in document) {
-                                var fieldValue = String(document[key]);
-                                if (fieldValue.toLowerCase().includes(query.toLowerCase())) {
-                                    return true;
-                                }
-                            }
-                            return false;
-                        });
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Full-text search completed successfully.',
-                                documentsCount: foundResults.length,
-                                foundResults: foundResults,
-                            }];
-                    case 2:
-                        error_17 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error performing full-text search.',
-                                documentsCount: 0,
-                                foundResults: [],
-                            }];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.takeSnapshot = function (snapshotPathWithFileName) {
-        return __awaiter(this, void 0, void 0, function () {
-            var data, snapshotPathComponents, snapshotFileName, snapshotPath, snapshotFilePath, error_18;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.dataPromise];
-                    case 1:
-                        data = _a.sent();
-                        snapshotPathComponents = snapshotPathWithFileName.split('/');
-                        snapshotFileName = snapshotPathComponents.pop() || "snapshot-".concat(Date.now(), ".json");
-                        snapshotPath = snapshotPathComponents.join('/');
-                        snapshotFilePath = "".concat(snapshotPath, "/").concat(snapshotFileName);
-                        return [4 /*yield*/, fs_1.promises.writeFile(snapshotFilePath, JSON.stringify(data, null, 2), 'utf8')];
-                    case 2:
-                        _a.sent();
-                        this.emit('snapshotTaken', {
-                            success: true,
-                            message: 'Snapshot taken successfully.',
-                            documentsCount: data.length,
-                            snapshotFilePath: snapshotFilePath,
-                            fileSizeInBytes: Buffer.from(JSON.stringify(data, null, 2)).length,
-                        });
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Snapshot taken successfully.',
-                                documentsCount: data.length,
-                                snapshotFilePath: snapshotFilePath,
-                                fileSizeInBytes: Buffer.from(JSON.stringify(data, null, 2)).length,
-                            }];
-                    case 3:
-                        error_18 = _a.sent();
-                        this.emit('snapshotError', {
-                            success: false,
-                            message: 'Error taking snapshot.',
-                            errorMessage: error_18.message,
-                            documentsCount: 0,
-                            fileSizeInBytes: 0,
-                        });
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error taking snapshot.',
-                                errorMessage: error_18.message,
-                                documentsCount: 0,
-                                fileSizeInBytes: 0,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    NanoDb.prototype.restoreSnapshot = function (snapshotIndex, filePath) {
-        return __awaiter(this, void 0, void 0, function () {
-            var directoryPath, fileName, snapshotFiles, snapshotRegex_1, matchingSnapshots, snapshotFilePath, snapshotData, error_19;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 4, , 5]);
-                        directoryPath = path.dirname(filePath);
-                        fileName = path.basename(filePath);
-                        return [4 /*yield*/, fs_1.promises.readdir(directoryPath)];
-                    case 1:
-                        snapshotFiles = _a.sent();
-                        snapshotRegex_1 = new RegExp("^".concat(fileName, "\\.snapshot-\\d+\\.json$"));
-                        matchingSnapshots = snapshotFiles.filter(function (file) { return snapshotRegex_1.test(file); });
-                        if (matchingSnapshots.length === 0) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    message: 'No snapshots found for restoration.',
-                                    documentsCount: 0,
-                                }];
-                        }
-                        matchingSnapshots.sort();
-                        if (snapshotIndex < 0 || snapshotIndex >= matchingSnapshots.length) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    message: 'Invalid snapshot index.',
-                                    documentsCount: 0,
-                                }];
-                        }
-                        snapshotFilePath = path.join(directoryPath, matchingSnapshots[snapshotIndex]);
-                        return [4 /*yield*/, fs_1.promises.readFile(snapshotFilePath, 'utf8')];
-                    case 2:
-                        snapshotData = _a.sent();
-                        return [4 /*yield*/, fs_1.promises.writeFile(filePath, snapshotData, 'utf8')];
-                    case 3:
-                        _a.sent();
-                        this.emit('snapshotRestored', {
-                            success: true,
-                            message: 'Snapshot restored successfully.',
-                            documentsCount: JSON.parse(snapshotData).length,
-                            snapshotFilePath: snapshotFilePath,
-                        });
-                        return [2 /*return*/, {
-                                success: true,
-                                message: 'Snapshot restored successfully.',
-                                documentsCount: JSON.parse(snapshotData).length,
-                                snapshotFilePath: snapshotFilePath,
-                            }];
-                    case 4:
-                        error_19 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                message: 'Error restoring snapshot.',
-                                errorMessage: error_19.message,
-                                documentsCount: 0,
-                            }];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return NanoDb;
-}(events_1.EventEmitter));
-exports.NanoDb = NanoDb;