apexify.js 1.2.9 → 2.1.0

package/lib/database/NanoDB.js

@@ -77,8 +77,9 @@ 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-browserify");
+var crypto = require("crypto");
 var NanoDb = /** @class */ (function (_super) {
     __extends(NanoDb, _super);
     function NanoDb(filePath) {
@@ -139,7 +140,7 @@ var NanoDb = /** @class */ (function (_super) {
     };
     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;
+            var data, filteredData, sortBy_1, sortOrder_1, page, pageSize, startIndex, endIndex, paginatedData, error_2;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -151,9 +152,10 @@ var NanoDb = /** @class */ (function (_super) {
                         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); });
+                        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;
@@ -271,10 +273,11 @@ var NanoDb = /** @class */ (function (_super) {
             });
         });
     };
-    NanoDb.prototype.updateData = function (filterQuery, updateOptions, upsert) {
+    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, indexToUpdate, updatedDocument, newDocument, error_5;
+            var data, existingDocumentsWithUniqueKeys, indexToUpdate, updatedDocument, newDocument, error_5;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -282,6 +285,27 @@ var NanoDb = /** @class */ (function (_super) {
                         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)];
@@ -681,7 +705,7 @@ var NanoDb = /** @class */ (function (_super) {
     };
     NanoDb.prototype.distinct = function (field) {
         return __awaiter(this, void 0, void 0, function () {
-            var data, distinctValues, error_12;
+            var data, distinctValues, valueSet, _i, data_2, document_2, fieldValue, error_12;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -689,7 +713,25 @@ var NanoDb = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.dataPromise];
                     case 1:
                         data = _a.sent();
-                        distinctValues = __spreadArray([], new Set(data.map(function (document) { return document[field]; })), true);
+                        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.',
@@ -724,357 +766,262 @@ var NanoDb = /** @class */ (function (_super) {
             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.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.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.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.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.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.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.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.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) {
+    NanoDb.prototype.decrypt = function (encryptedData, decryptKey) {
+        if (!decryptKey) {
             throw new Error('Encryption key is required for decryption.');
         }
-        var decipher = crypto.createDecipher('aes-256-cbc', Buffer.from(this.encryptionKey, 'utf8'));
+        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 () {
-            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) {
+            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();
-                        _a.label = 1;
+                        totalSize = 0;
+                        fileSizes = {};
+                        _b.label = 1;
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        totalSize_1 = 0;
-                        return [4 /*yield*/, processDirectory(projectRoot)];
+                        _b.trys.push([1, 13, , 14]);
+                        return [4 /*yield*/, fs_1.promises.readdir(projectRoot)];
                     case 2:
-                        _a.sent();
-                        return [2 /*return*/, totalSize_1];
+                        files = _b.sent();
+                        _i = 0, files_1 = files;
+                        _b.label = 3;
                     case 3:
-                        error_15 = _a.sent();
-                        console.error('Error calculating total size:', error_15.message);
-                        return [2 /*return*/, 0];
-                    case 4: return [2 /*return*/];
+                        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 (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.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_2, result, error_18;
+            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_2 = _a.sent();
+                        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 key = stage.$group._id || 'defaultGroup';
-                                    var keyValue = String(document[key]);
+                                    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, function (_a) {
-                                    var _b;
-                                    var key = _a[0], value = _a[1];
-                                    return (_b = {}, _b[key] = value, _b);
+                                acc = Array.from(groupedData_1.values(), function (value) {
+                                    var _a;
+                                    return (_a = {}, _a[key_1] = value, _a);
                                 });
                             }
                             else if (stage.$project) {
@@ -1089,9 +1036,9 @@ var NanoDb = /** @class */ (function (_super) {
                                 });
                             }
                             else if (stage.$sort) {
-                                var sortBy_1 = stage.$sort.field;
+                                var sortBy_2 = 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); });
+                                acc.sort(function (a, b) { return (a[sortBy_2] > b[sortBy_2] ? sortOrder_2 : -sortOrder_2); });
                             }
                             else if (stage.$skip) {
                                 var skipCount = stage.$skip;
@@ -1112,14 +1059,13 @@ var NanoDb = /** @class */ (function (_super) {
                                 });
                             }
                             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; });
+                                    var matchingDocuments = data_3.filter(function (lookupDoc) { return lookupDoc[foreignField_1] === lookupValue; });
                                     return __assign(__assign({}, document), (_a = {}, _a[asField_1] = matchingDocuments, _a));
                                 });
                             }
@@ -1140,7 +1086,7 @@ var NanoDb = /** @class */ (function (_super) {
                                 acc = [{ count: acc.length }];
                             }
                             return acc;
-                        }, data_2);
+                        }, data_3);
                         return [2 /*return*/, {
                                 success: true,
                                 message: 'Aggregation completed successfully.',
@@ -1148,11 +1094,11 @@ var NanoDb = /** @class */ (function (_super) {
                                 aggregatedResults: result,
                             }];
                     case 2:
-                        error_18 = _a.sent();
+                        error_14 = _a.sent();
                         return [2 /*return*/, {
                                 success: false,
                                 message: 'Error performing aggregation.',
-                                errorMessage: error_18.message,
+                                errorMessage: error_14.message,
                                 documentsCount: 0,
                                 aggregatedResults: [],
                             }];
@@ -1161,9 +1107,87 @@ var NanoDb = /** @class */ (function (_super) {
             });
         });
     };
+    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_19;
+            var data, foundResults, error_17;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1187,7 +1211,7 @@ var NanoDb = /** @class */ (function (_super) {
                                 foundResults: foundResults,
                             }];
                     case 2:
-                        error_19 = _a.sent();
+                        error_17 = _a.sent();
                         return [2 /*return*/, {
                                 success: false,
                                 message: 'Error performing full-text search.',
@@ -1201,7 +1225,7 @@ var NanoDb = /** @class */ (function (_super) {
     };
     NanoDb.prototype.takeSnapshot = function (snapshotPathWithFileName) {
         return __awaiter(this, void 0, void 0, function () {
-            var data, snapshotPathComponents, snapshotFileName, snapshotPath, snapshotFilePath, error_20;
+            var data, snapshotPathComponents, snapshotFileName, snapshotPath, snapshotFilePath, error_18;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1231,18 +1255,18 @@ var NanoDb = /** @class */ (function (_super) {
                                 fileSizeInBytes: Buffer.from(JSON.stringify(data, null, 2)).length,
                             }];
                     case 3:
-                        error_20 = _a.sent();
+                        error_18 = _a.sent();
                         this.emit('snapshotError', {
                             success: false,
                             message: 'Error taking snapshot.',
-                            errorMessage: error_20.message,
+                            errorMessage: error_18.message,
                             documentsCount: 0,
                             fileSizeInBytes: 0,
                         });
                         return [2 /*return*/, {
                                 success: false,
                                 message: 'Error taking snapshot.',
-                                errorMessage: error_20.message,
+                                errorMessage: error_18.message,
                                 documentsCount: 0,
                                 fileSizeInBytes: 0,
                             }];
@@ -1253,7 +1277,7 @@ var NanoDb = /** @class */ (function (_super) {
     };
     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;
+            var directoryPath, fileName, snapshotFiles, snapshotRegex_1, matchingSnapshots, snapshotFilePath, snapshotData, error_19;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -1300,11 +1324,11 @@ var NanoDb = /** @class */ (function (_super) {
                                 snapshotFilePath: snapshotFilePath,
                             }];
                     case 4:
-                        error_21 = _a.sent();
+                        error_19 = _a.sent();
                         return [2 /*return*/, {
                                 success: false,
                                 message: 'Error restoring snapshot.',
-                                errorMessage: error_21.message,
+                                errorMessage: error_19.message,
                                 documentsCount: 0,
                             }];
                     case 5: return [2 /*return*/];
@@ -1314,5 +1338,4 @@ var NanoDb = /** @class */ (function (_super) {
     };
     return NanoDb;
 }(events_1.EventEmitter));
-
 exports.NanoDb = NanoDb;