apexify.js 1.2.1

package/lib/database/NanoDB.js

@@ -0,0 +1,1318 @@
+"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 path = require("path");
+var crypto = require("crypto-browserify");
+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, 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); });
+                        }
+                        if (options === null || options === void 0 ? void 0 : options.sortBy) {
+                            sortOrder_1 = (options === null || options === void 0 ? void 0 : options.sortOrder) === 'desc' ? -1 : 1;
+                            filteredData.sort(function (a, b) { return (a[options.sortBy] > b[options.sortBy] ? 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, upsert) {
+        if (upsert === void 0) { upsert = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var data, 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();
+                        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, 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 = __spreadArray([], new Set(data.map(function (document) { return document[field]; })), true);
+                        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 (filepath, format) {
+        if (format === void 0) { format = 'txt'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var data, serializedData, _a, zipBackupResult, gzipBackupResult, transferDataResult, error_13;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 12, , 13]);
+                        return [4 /*yield*/, this.dataPromise];
+                    case 1:
+                        data = _b.sent();
+                        serializedData = void 0;
+                        _a = format;
+                        switch (_a) {
+                            case 'txt': return [3 /*break*/, 2];
+                            case 'zip': return [3 /*break*/, 3];
+                            case 'gzip': return [3 /*break*/, 5];
+                            case 'json': return [3 /*break*/, 7];
+                        }
+                        return [3 /*break*/, 9];
+                    case 2:
+                        serializedData = JSON.stringify(data, null, 2);
+                        return [3 /*break*/, 10];
+                    case 3: return [4 /*yield*/, this.createCompressedBackup(filepath, data, 'zip')];
+                    case 4:
+                        zipBackupResult = _b.sent();
+                        this.emit('backupCreated', zipBackupResult);
+                        return [2 /*return*/, zipBackupResult];
+                    case 5: return [4 /*yield*/, this.createCompressedBackup(filepath, data, 'gzip')];
+                    case 6:
+                        gzipBackupResult = _b.sent();
+                        this.emit('backupCreated', gzipBackupResult);
+                        return [2 /*return*/, gzipBackupResult];
+                    case 7: return [4 /*yield*/, this.transferData(filepath)];
+                    case 8:
+                        transferDataResult = _b.sent();
+                        this.emit('backupCreated', transferDataResult);
+                        return [2 /*return*/, transferDataResult];
+                    case 9: return [2 /*return*/, {
+                            success: false,
+                            message: 'Unsupported backup format.',
+                            documentsCount: 0,
+                            fileSizeInBytes: 0,
+                        }];
+                    case 10: return [4 /*yield*/, fs_1.promises.writeFile(filepath, serializedData, 'utf8')];
+                    case 11:
+                        _b.sent();
+                        this.emit('backupCreated', {
+                            success: true,
+                            message: "Backup created successfully in ".concat(format, " format."),
+                            documentsCount: data.length,
+                            fileSizeInBytes: Buffer.from(serializedData).length,
+                        });
+                        return [2 /*return*/, {
+                                success: true,
+                                message: "Backup created successfully in ".concat(format, " format."),
+                                documentsCount: data.length,
+                                fileSizeInBytes: Buffer.from(serializedData).length,
+                            }];
+                    case 12:
+                        error_13 = _b.sent();
+                        this.emit('backupError', {
+                            success: false,
+                            message: 'Error creating backup.',
+                            errorMessage: error_13.message,
+                            documentsCount: 0,
+                            fileSizeInBytes: 0,
+                        });
+                        return [2 /*return*/, {
+                                success: false,
+                                message: 'Error creating backup.',
+                                errorMessage: error_13.message,
+                                documentsCount: 0,
+                                fileSizeInBytes: 0,
+                            }];
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NanoDb.prototype.createCompressedBackup = function (filepath, data, compression) {
+        return __awaiter(this, void 0, void 0, function () {
+            var compressedData, _a, error_14;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 8, , 9]);
+                        compressedData = void 0;
+                        _a = compression;
+                        switch (_a) {
+                            case 'zip': return [3 /*break*/, 1];
+                            case 'gzip': return [3 /*break*/, 3];
+                        }
+                        return [3 /*break*/, 5];
+                    case 1: return [4 /*yield*/, this.zipData(data)];
+                    case 2:
+                        compressedData = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 3: return [4 /*yield*/, this.gzipData(data)];
+                    case 4:
+                        compressedData = _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5: return [2 /*return*/, {
+                            success: false,
+                            message: 'Unsupported compression format.',
+                            documentsCount: 0,
+                            fileSizeInBytes: 0,
+                        }];
+                    case 6: return [4 /*yield*/, fs_1.promises.writeFile(filepath, compressedData)];
+                    case 7:
+                        _b.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                message: "Backup created successfully in ".concat(compression, " format."),
+                                documentsCount: data.length,
+                                fileSizeInBytes: compressedData.length,
+                            }];
+                    case 8:
+                        error_14 = _b.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                message: 'Error creating compressed backup.',
+                                errorMessage: error_14.message,
+                                documentsCount: 0,
+                                fileSizeInBytes: 0,
+                            }];
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NanoDb.prototype.zipData = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var serializedData;
+            return __generator(this, function (_a) {
+                serializedData = JSON.stringify(data, null, 2);
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        zlib.gzip(serializedData, function (err, buffer) {
+                            if (err) {
+                                reject(err);
+                            }
+                            else {
+                                resolve(buffer);
+                            }
+                        });
+                    })];
+            });
+        });
+    };
+    NanoDb.prototype.gzipData = function (data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var serializedData;
+            return __generator(this, function (_a) {
+                serializedData = JSON.stringify(data, null, 2);
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        zlib.gzip(serializedData, function (err, buffer) {
+                            if (err) {
+                                reject(err);
+                            }
+                            else {
+                                resolve(buffer);
+                            }
+                        });
+                    })];
+            });
+        });
+    };
+    NanoDb.prototype.loadEncryptedData = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var encryptedData, decryptedData, err_2;
+            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:
+                        encryptedData = _a.sent();
+                        decryptedData = this.decrypt(encryptedData);
+                        return [2 /*return*/, JSON.parse(decryptedData)];
+                    case 2:
+                        err_2 = _a.sent();
+                        return [2 /*return*/, []];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NanoDb.prototype.encrypt = function (data) {
+        if (!this.encryptionKey) {
+            throw new Error('Encryption key is required for encryption.');
+        }
+        var cipher = crypto.createCipher('aes-256-cbc', Buffer.from(this.encryptionKey, 'utf8'));
+        var encrypted = cipher.update(data, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return encrypted;
+    };
+    NanoDb.prototype.decrypt = function (encryptedData) {
+        if (!this.encryptionKey) {
+            throw new Error('Encryption key is required for decryption.');
+        }
+        var decipher = crypto.createDecipher('aes-256-cbc', Buffer.from(this.encryptionKey, 'utf8'));
+        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 () {
+            function processDirectory(directoryPath) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var files, _i, files_1, file, filePath, stats, error_16;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 9, , 10]);
+                                return [4 /*yield*/, fs.readdir(directoryPath)];
+                            case 1:
+                                files = _a.sent();
+                                _i = 0, files_1 = files;
+                                _a.label = 2;
+                            case 2:
+                                if (!(_i < files_1.length)) return [3 /*break*/, 8];
+                                file = files_1[_i];
+                                filePath = path.join(directoryPath, file);
+                                return [4 /*yield*/, fs.stat(filePath)];
+                            case 3:
+                                stats = _a.sent();
+                                if (!stats.isDirectory()) return [3 /*break*/, 6];
+                                if (!!filePath.includes('node_modules')) return [3 /*break*/, 5];
+                                return [4 /*yield*/, processDirectory(filePath)];
+                            case 4:
+                                _a.sent();
+                                _a.label = 5;
+                            case 5: return [3 /*break*/, 7];
+                            case 6:
+                                if (path.extname(filePath).toLowerCase() === '.json') {
+                                    totalSize_1 += stats.size;
+                                }
+                                _a.label = 7;
+                            case 7:
+                                _i++;
+                                return [3 /*break*/, 2];
+                            case 8: return [3 /*break*/, 10];
+                            case 9:
+                                error_16 = _a.sent();
+                                console.error('Error reading directory:', error_16.message);
+                                return [3 /*break*/, 10];
+                            case 10: return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+            var projectRoot, totalSize_1, error_15;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        projectRoot = process.cwd();
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        totalSize_1 = 0;
+                        return [4 /*yield*/, processDirectory(projectRoot)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, totalSize_1];
+                    case 3:
+                        error_15 = _a.sent();
+                        console.error('Error calculating total size:', error_15.message);
+                        return [2 /*return*/, 0];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NanoDb.prototype.replicate = function (fileToReplicate, replicatePath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sourceData, fileName, destinationFilePath, error_17;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 3, , 4]);
+                        return [4 /*yield*/, fs_1.promises.readFile(fileToReplicate, 'utf8')];
+                    case 1:
+                        sourceData = _a.sent();
+                        fileName = path.basename(fileToReplicate);
+                        destinationFilePath = path.join(replicatePath, fileName);
+                        return [4 /*yield*/, fs_1.promises.writeFile(destinationFilePath, sourceData, 'utf8')];
+                    case 2:
+                        _a.sent();
+                        this.emit('dataReplicated', {
+                            success: true,
+                            message: 'Data replicated successfully.',
+                            documentsCount: 'Full',
+                            destinationFilePath: destinationFilePath,
+                            fileSizeInBytes: Buffer.from(sourceData).length,
+                        });
+                        return [2 /*return*/, {
+                                success: true,
+                                message: 'Data replicated successfully.',
+                                documentsCount: 'Full',
+                                destinationFilePath: destinationFilePath,
+                                fileSizeInBytes: Buffer.from(sourceData).length,
+                            }];
+                    case 3:
+                        error_17 = _a.sent();
+                        this.emit('replicationError', {
+                            success: false,
+                            message: 'Error replicating data.',
+                            errorMessage: error_17.message,
+                            documentsCount: 0,
+                            fileSizeInBytes: 0,
+                        });
+                        return [2 /*return*/, {
+                                success: false,
+                                message: 'Error replicating data.',
+                                errorMessage: error_17.message,
+                                documentsCount: 0,
+                                fileSizeInBytes: 0,
+                            }];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NanoDb.prototype.aggregate = function (pipeline) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data_2, result, error_18;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.dataPromise];
+                    case 1:
+                        data_2 = _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();
+                                acc.forEach(function (document) {
+                                    var key = stage.$group._id || 'defaultGroup';
+                                    var keyValue = String(document[key]);
+                                    if (!groupedData_1.has(keyValue)) {
+                                        groupedData_1.set(keyValue, []);
+                                    }
+                                    groupedData_1.get(keyValue).push(document);
+                                });
+                                acc = Array.from(groupedData_1, function (_a) {
+                                    var _b;
+                                    var key = _a[0], value = _a[1];
+                                    return (_b = {}, _b[key] = value, _b);
+                                });
+                            }
+                            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_1 = stage.$sort.field;
+                                var sortOrder_2 = stage.$sort.order === 'desc' ? -1 : 1;
+                                acc.sort(function (a, b) { return (a[sortBy_1] > b[sortBy_1] ? 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 lookupField = stage.$lookup.from;
+                                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_2.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_2);
+                        return [2 /*return*/, {
+                                success: true,
+                                message: 'Aggregation completed successfully.',
+                                documentsCount: result.length,
+                                aggregatedResults: result,
+                            }];
+                    case 2:
+                        error_18 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                message: 'Error performing aggregation.',
+                                errorMessage: error_18.message,
+                                documentsCount: 0,
+                                aggregatedResults: [],
+                            }];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NanoDb.prototype.fullTextSearch = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, foundResults, error_19;
+            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_19 = _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_20;
+            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_20 = _a.sent();
+                        this.emit('snapshotError', {
+                            success: false,
+                            message: 'Error taking snapshot.',
+                            errorMessage: error_20.message,
+                            documentsCount: 0,
+                            fileSizeInBytes: 0,
+                        });
+                        return [2 /*return*/, {
+                                success: false,
+                                message: 'Error taking snapshot.',
+                                errorMessage: error_20.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_21;
+            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_21 = _a.sent();
+                        return [2 /*return*/, {
+                                success: false,
+                                message: 'Error restoring snapshot.',
+                                errorMessage: error_21.message,
+                                documentsCount: 0,
+                            }];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return NanoDb;
+}(events_1.EventEmitter));
+
+exports.NanoDb = NanoDb;