@shaaz1000/rn-storage
Version:
A comprehensive storage solution for React Native with encryption, caching, and offline sync
138 lines • 4.41 kB
JavaScript
;
// src/core/storageManager.ts
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const encryption_1 = __importDefault(require("../utils/encryption"));
const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
class StorageManager {
constructor() {
this.memoryCache = {};
// Private constructor for singleton
}
/**
* Initialize storage with encryption key
* @param encryptionKey - Key used for encrypting/decrypting data
*/
static initialize(encryptionKey) {
encryption_1.default.initialize(encryptionKey);
}
static getInstance() {
if (!StorageManager.instance) {
StorageManager.instance = new StorageManager();
}
return StorageManager.instance;
}
/**
* Set item in storage
* @param key - Storage key
* @param value - Value to store
* @param encrypt - Whether to encrypt the data
* @param expiryTime - Time in milliseconds after which the data expires
*/
async setItem(key, value, encrypt = false, expiryTime) {
const storageData = {
value: encrypt ? encryption_1.default.encrypt(value) : value,
timestamp: Date.now(),
expiryTime
};
// Store in memory cache
this.memoryCache[key] = storageData;
// Store in AsyncStorage
try {
await async_storage_1.default.setItem(key, JSON.stringify(storageData));
}
catch (error) {
console.error('Error storing data:', error);
throw new Error('Failed to store data');
}
}
/**
* Get item from storage
* @param key - Storage key
* @param decrypt - Whether to decrypt the data
*/
async getItem(key, decrypt = false) {
try {
// Try memory cache first
let data = this.memoryCache[key];
// If not in memory cache, try AsyncStorage
if (!data) {
const storedData = await async_storage_1.default.getItem(key);
if (storedData) {
data = JSON.parse(storedData);
this.memoryCache[key] = data; // Update memory cache
}
}
if (!data)
return null;
// Check if data has expired
if (data.expiryTime && Date.now() - data.timestamp > data.expiryTime) {
await this.removeItem(key);
return null;
}
return decrypt ? encryption_1.default.decrypt(data.value) : data.value;
}
catch (error) {
console.error('Error retrieving data:', error);
return null;
}
}
/**
* Remove item from storage
* @param key - Storage key
*/
async removeItem(key) {
try {
delete this.memoryCache[key];
await async_storage_1.default.removeItem(key);
}
catch (error) {
console.error('Error removing data:', error);
throw new Error('Failed to remove data');
}
}
/**
* Clear all storage
*/
async clear() {
try {
this.memoryCache = {};
await async_storage_1.default.clear();
}
catch (error) {
console.error('Error clearing storage:', error);
throw new Error('Failed to clear storage');
}
}
/**
* Get all keys in storage
*/
async getAllKeys() {
try {
const keys = await async_storage_1.default.getAllKeys();
return [...keys]; // Convert readonly array to mutable array
}
catch (error) {
console.error('Error getting keys:', error);
return [];
}
}
/**
* Check if key exists in storage
* @param key - Storage key
*/
async hasKey(key) {
try {
const value = await async_storage_1.default.getItem(key);
return value !== null;
}
catch (error) {
console.error('Error checking key:', error);
return false;
}
}
}
exports.default = StorageManager;
//# sourceMappingURL=storageManager.js.map