system-secured-storage
Version:
A Node.js project that allows users to store encrypted key-value data locally on their system. This project serves as an alternate storage solution to SQLite but with enhanced security features, leveraging AES encryption to ensure the confidentiality and
178 lines • 6.27 kB
JavaScript
;
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());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SystemSecuredStorage = void 0;
const save_file_util_1 = require("../utils/save-file.util");
const encryption_service_1 = require("./encryption.service");
/**
* Securely store data on you system.
*
* @exports
* @class SystemSecuredStorage
*
* ```
* // Example
* import SystemSecuredStorage from 'system-secured-storage';
*
* const storage = new SystemSecuredStorage(options)
*
* // Encrypt and store the key-value pair
* storage.storeData('myKey', 'mySensitiveData');
*
* // Retrieve and decrypt the data using the key
* const decryptedData = storage.retrieveData('myKey');
* ```
*/
class SystemSecuredStorage {
/**
* Create an instance of the SystemSecuredStorage.
*
* @param {SystemSecuredStorageOptions} options - Options
*/
constructor({ directory, encryptionKey, ivKey }) {
/**
* Retrieve all stored data.
*
* @returns
*/
this.retrieveAll = () => {
const encryptedData = (0, save_file_util_1.retrieveDataLocallySync)(this.fileDirectory);
if (!encryptedData)
return undefined;
return this.encryptionService.decrypt(encryptedData);
};
/**
* Asynchronously retrieve all stored data.
*
* @param {void} callback - Callback function.
* @returns
*/
this.retrieveAllAsync = (callback) => {
return (0, save_file_util_1.retrieveDataLocallyAsync)(this.fileDirectory, (error, data) => {
if (error || !data)
callback(error, undefined);
else
callback(null, this.encryptionService.decrypt(data));
});
};
/**
* Encrypt data.
*
* @param storedData - The stored data locally.
* @param {string} key - The key of the data to add.
* @param {string} data - The data.
* @returns
*/
this.encryptData = (storedData, key, data) => {
const _storedData = storedData ? Object.assign(Object.assign({}, storedData), { [key]: data }) : { [key]: data };
return this.encryptionService.encrypt(_storedData);
};
this.fileDirectory = directory;
this.encryptionService = new encryption_service_1.EncryptionService(encryptionKey, ivKey);
}
/**
* Store data.
*
* @param {string} key - The key.
* @param {string} data - The data.
*/
storeData(key, data) {
const storedData = this.retrieveAll();
const encryptedData = this.encryptData(storedData, key, data);
(0, save_file_util_1.saveDataLocallySync)(this.fileDirectory, encryptedData);
}
/**
* Asynchronously store data.
*
* @param {string} key - The key.
* @param {string} data - The data.
* @param {void} callback - Callback function.
*/
storeDataAsync(key, data, callback) {
this.retrieveAllAsync((err, storedData) => {
const encryptedData = this.encryptData(storedData, key, data);
(0, save_file_util_1.saveDataLocallyAsync)(this.fileDirectory, encryptedData, callback);
});
}
/**
* Retrieve store data.
*
* @param {string} key - The key the data stored in.
* @returns {T} The data stored.
*/
retrieveData(key) {
const storedData = this.retrieveAll();
if (!storedData)
return undefined;
return storedData[key];
}
/**
* Asynchronously retrieve store data.
*
* @param {string} key - The key the data stored in.
* @param {void} callback - Callback function.
* @returns {T} The data stored.
*/
retrieveDataAsync(key, callback) {
this.retrieveAllAsync((err, storedData) => {
if (err || !storedData)
callback(err, undefined);
else
callback(null, storedData[key]);
});
}
/**
* Delete stored data.
*
* @param {string} key - The key the data stored in.
* @returns
*/
deleteData(key) {
const storedData = this.retrieveAll();
if (!storedData)
return undefined;
delete storedData[key];
const encryptedData = this.encryptionService.encrypt(storedData);
(0, save_file_util_1.saveDataLocallySync)(this.fileDirectory, encryptedData);
}
/**
* Asynchronously delete stored data.
*
* @param {string} key - The key the data stored in.
* @param {void} callback - Callback function.
* @returns
*/
deleteDataAsync(key, callback) {
this.retrieveAllAsync((err, storedData) => __awaiter(this, void 0, void 0, function* () {
if (err || !storedData)
return;
delete storedData[key];
const encryptedData = this.encryptionService.encrypt(storedData);
(0, save_file_util_1.saveDataLocallyAsync)(this.fileDirectory, encryptedData, callback);
}));
}
/**
* Reset storage.
*/
reset() {
(0, save_file_util_1.saveDataLocallySync)(this.fileDirectory, '');
}
/**
* Asynchronously reset storage.
*
* @param {void} callback - Callback function.
*/
resetAsync(callback) {
(0, save_file_util_1.saveDataLocallyAsync)(this.fileDirectory, '', callback);
}
}
exports.SystemSecuredStorage = SystemSecuredStorage;
//# sourceMappingURL=system-secured-storage.service.js.map