react-native-ble-mesh 1.0.1

package/src/storage/AsyncStorageAdapter.js

@@ -0,0 +1,303 @@
+'use strict';
+
+/**
+ * @fileoverview React Native AsyncStorage adapter
+ * @module storage/AsyncStorageAdapter
+ */
+
+const Storage = require('./Storage');
+
+/**
+ * React Native AsyncStorage adapter.
+ * Wraps @react-native-async-storage/async-storage for persistent storage.
+ *
+ * NOTE: @react-native-async-storage/async-storage is an optional peer dependency.
+ * Install it separately: npm install @react-native-async-storage/async-storage
+ *
+ * @class AsyncStorageAdapter
+ * @extends Storage
+ */
+class AsyncStorageAdapter extends Storage {
+  /**
+   * Creates a new AsyncStorageAdapter instance
+   * @param {Object} [options={}] - Storage options
+   * @param {string} [options.prefix='mesh'] - Key prefix for namespacing
+   * @param {Object} [options.AsyncStorage] - AsyncStorage instance (optional)
+   */
+  constructor(options = {}) {
+    super({
+      prefix: 'mesh',
+      ...options
+    });
+
+    /**
+     * AsyncStorage instance
+     * @type {Object|null}
+     * @private
+     */
+    this._storage = options.AsyncStorage || null;
+
+    /**
+     * Whether adapter is initialized
+     * @type {boolean}
+     * @private
+     */
+    this._initialized = false;
+  }
+
+  /**
+   * Initializes the AsyncStorage adapter
+   * @returns {Promise<void>}
+   * @throws {Error} If AsyncStorage is not available
+   */
+  async initialize() {
+    if (this._initialized) {
+      return;
+    }
+
+    // Try to load AsyncStorage if not provided
+    if (!this._storage) {
+      try {
+        const AsyncStorageModule = require('@react-native-async-storage/async-storage');
+        this._storage = AsyncStorageModule.default || AsyncStorageModule;
+      } catch (error) {
+        throw new Error(
+          '@react-native-async-storage/async-storage is required. ' +
+          'Install with: npm install @react-native-async-storage/async-storage'
+        );
+      }
+    }
+
+    this._initialized = true;
+  }
+
+  /**
+   * Ensures the adapter is initialized
+   * @throws {Error} If not initialized
+   * @private
+   */
+  _ensureInitialized() {
+    if (!this._initialized) {
+      throw new Error('AsyncStorageAdapter is not initialized. Call initialize() first.');
+    }
+  }
+
+  /**
+   * Gets a value by key
+   * @param {string} key - Key to retrieve
+   * @returns {Promise<any>} Stored value or undefined
+   */
+  async get(key) {
+    this._ensureInitialized();
+
+    const prefixedKey = this._getKey(key);
+    const jsonValue = await this._storage.getItem(prefixedKey);
+
+    if (jsonValue === null) {
+      return undefined;
+    }
+
+    try {
+      const item = JSON.parse(jsonValue);
+
+      // Check for expiration
+      if (item.expiresAt && Date.now() > item.expiresAt) {
+        await this._storage.removeItem(prefixedKey);
+        return undefined;
+      }
+
+      return item.value;
+    } catch (error) {
+      // If JSON parsing fails, return raw value (legacy data)
+      return jsonValue;
+    }
+  }
+
+  /**
+   * Sets a value by key
+   * @param {string} key - Key to set
+   * @param {any} value - Value to store
+   * @param {Object} [options={}] - Set options
+   * @param {number} [options.ttl] - Time to live in milliseconds
+   * @returns {Promise<void>}
+   */
+  async set(key, value, options = {}) {
+    this._ensureInitialized();
+
+    const prefixedKey = this._getKey(key);
+
+    const item = {
+      value,
+      createdAt: Date.now()
+    };
+
+    if (options.ttl && options.ttl > 0) {
+      item.expiresAt = Date.now() + options.ttl;
+    }
+
+    const jsonValue = JSON.stringify(item);
+    await this._storage.setItem(prefixedKey, jsonValue);
+  }
+
+  /**
+   * Deletes a value by key
+   * @param {string} key - Key to delete
+   * @returns {Promise<void>}
+   */
+  async delete(key) {
+    this._ensureInitialized();
+
+    const prefixedKey = this._getKey(key);
+    await this._storage.removeItem(prefixedKey);
+  }
+
+  /**
+   * Checks if a key exists
+   * @param {string} key - Key to check
+   * @returns {Promise<boolean>} True if key exists
+   */
+  async has(key) {
+    const value = await this.get(key);
+    return value !== undefined;
+  }
+
+  /**
+   * Clears all stored data with our prefix
+   * @returns {Promise<void>}
+   */
+  async clear() {
+    this._ensureInitialized();
+
+    const allKeys = await this._storage.getAllKeys();
+    const prefix = `${this._options.prefix}:`;
+    const keysToRemove = allKeys.filter(key => key.startsWith(prefix));
+
+    if (keysToRemove.length > 0) {
+      await this._storage.multiRemove(keysToRemove);
+    }
+  }
+
+  /**
+   * Gets all keys (without prefix)
+   * @returns {Promise<string[]>} Array of keys
+   */
+  async keys() {
+    this._ensureInitialized();
+
+    const allKeys = await this._storage.getAllKeys();
+    const prefix = `${this._options.prefix}:`;
+
+    return allKeys
+      .filter(key => key.startsWith(prefix))
+      .map(key => key.slice(prefix.length));
+  }
+
+  /**
+   * Gets multiple values by keys
+   * @param {string[]} keys - Keys to retrieve
+   * @returns {Promise<Map<string, any>>} Map of key-value pairs
+   */
+  async getMany(keys) {
+    this._ensureInitialized();
+
+    const prefixedKeys = keys.map(key => this._getKey(key));
+    const pairs = await this._storage.multiGet(prefixedKeys);
+    const result = new Map();
+    const now = Date.now();
+
+    for (const [prefixedKey, jsonValue] of pairs) {
+      if (jsonValue !== null) {
+        const key = prefixedKey.slice(this._options.prefix.length + 1);
+        try {
+          const item = JSON.parse(jsonValue);
+          if (!item.expiresAt || now <= item.expiresAt) {
+            result.set(key, item.value);
+          }
+        } catch (error) {
+          result.set(key, jsonValue);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Sets multiple key-value pairs
+   * @param {Map<string, any>|Object} entries - Entries to set
+   * @param {Object} [options={}] - Set options
+   * @param {number} [options.ttl] - Time to live in milliseconds
+   * @returns {Promise<void>}
+   */
+  async setMany(entries, options = {}) {
+    this._ensureInitialized();
+
+    const pairs = entries instanceof Map
+      ? Array.from(entries.entries())
+      : Object.entries(entries);
+
+    const now = Date.now();
+    const keyValuePairs = pairs.map(([key, value]) => {
+      const item = {
+        value,
+        createdAt: now
+      };
+
+      if (options.ttl && options.ttl > 0) {
+        item.expiresAt = now + options.ttl;
+      }
+
+      return [this._getKey(key), JSON.stringify(item)];
+    });
+
+    await this._storage.multiSet(keyValuePairs);
+  }
+
+  /**
+   * Deletes multiple keys
+   * @param {string[]} keys - Keys to delete
+   * @returns {Promise<void>}
+   */
+  async deleteMany(keys) {
+    this._ensureInitialized();
+
+    const prefixedKeys = keys.map(key => this._getKey(key));
+    await this._storage.multiRemove(prefixedKeys);
+  }
+
+  /**
+   * Cleans up expired items
+   * @returns {Promise<number>} Number of items removed
+   */
+  async cleanup() {
+    this._ensureInitialized();
+
+    const allKeys = await this.keys();
+    const now = Date.now();
+    const keysToRemove = [];
+
+    for (const key of allKeys) {
+      const prefixedKey = this._getKey(key);
+      const jsonValue = await this._storage.getItem(prefixedKey);
+
+      if (jsonValue !== null) {
+        try {
+          const item = JSON.parse(jsonValue);
+          if (item.expiresAt && now > item.expiresAt) {
+            keysToRemove.push(prefixedKey);
+          }
+        } catch (error) {
+          // Ignore parse errors
+        }
+      }
+    }
+
+    if (keysToRemove.length > 0) {
+      await this._storage.multiRemove(keysToRemove);
+    }
+
+    return keysToRemove.length;
+  }
+}
+
+module.exports = AsyncStorageAdapter;

package/src/storage/MemoryStorage.js

@@ -0,0 +1,225 @@
+'use strict';
+
+/**
+ * @fileoverview In-memory storage implementation
+ * @module storage/MemoryStorage
+ */
+
+const Storage = require('./Storage');
+
+/**
+ * In-memory storage implementation.
+ * Stores data in a JavaScript Map. Data is not persisted across restarts.
+ * Useful for testing and temporary storage.
+ *
+ * @class MemoryStorage
+ * @extends Storage
+ */
+class MemoryStorage extends Storage {
+  /**
+   * Creates a new MemoryStorage instance
+   * @param {Object} [options={}] - Storage options
+   * @param {string} [options.prefix=''] - Key prefix for namespacing
+   * @param {number} [options.maxSize=0] - Maximum number of items (0 = unlimited)
+   */
+  constructor(options = {}) {
+    super(options);
+
+    /**
+     * Internal storage map
+     * @type {Map<string, any>}
+     * @private
+     */
+    this._store = new Map();
+
+    /**
+     * Maximum storage size (0 = unlimited)
+     * @type {number}
+     * @private
+     */
+    this._maxSize = options.maxSize || 0;
+  }
+
+  /**
+   * Gets a value by key
+   * @param {string} key - Key to retrieve
+   * @returns {Promise<any>} Stored value or undefined
+   */
+  async get(key) {
+    const prefixedKey = this._getKey(key);
+    const item = this._store.get(prefixedKey);
+
+    if (item === undefined) {
+      return undefined;
+    }
+
+    // Check for expiration if item has TTL
+    if (item.expiresAt && Date.now() > item.expiresAt) {
+      this._store.delete(prefixedKey);
+      return undefined;
+    }
+
+    return item.value;
+  }
+
+  /**
+   * Sets a value by key
+   * @param {string} key - Key to set
+   * @param {any} value - Value to store
+   * @param {Object} [options={}] - Set options
+   * @param {number} [options.ttl] - Time to live in milliseconds
+   * @returns {Promise<void>}
+   */
+  async set(key, value, options = {}) {
+    const prefixedKey = this._getKey(key);
+
+    // Check size limit
+    if (this._maxSize > 0 &&
+        !this._store.has(prefixedKey) &&
+        this._store.size >= this._maxSize) {
+      // Remove oldest entry (first entry in Map)
+      const firstKey = this._store.keys().next().value;
+      this._store.delete(firstKey);
+    }
+
+    const item = {
+      value,
+      createdAt: Date.now()
+    };
+
+    if (options.ttl && options.ttl > 0) {
+      item.expiresAt = Date.now() + options.ttl;
+    }
+
+    this._store.set(prefixedKey, item);
+  }
+
+  /**
+   * Deletes a value by key
+   * @param {string} key - Key to delete
+   * @returns {Promise<void>}
+   */
+  async delete(key) {
+    const prefixedKey = this._getKey(key);
+    this._store.delete(prefixedKey);
+  }
+
+  /**
+   * Checks if a key exists
+   * @param {string} key - Key to check
+   * @returns {Promise<boolean>} True if key exists
+   */
+  async has(key) {
+    const prefixedKey = this._getKey(key);
+    const item = this._store.get(prefixedKey);
+
+    if (item === undefined) {
+      return false;
+    }
+
+    // Check for expiration
+    if (item.expiresAt && Date.now() > item.expiresAt) {
+      this._store.delete(prefixedKey);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Clears all stored data
+   * @returns {Promise<void>}
+   */
+  async clear() {
+    if (this._options.prefix) {
+      // Only clear keys with our prefix
+      for (const key of this._store.keys()) {
+        if (key.startsWith(`${this._options.prefix}:`)) {
+          this._store.delete(key);
+        }
+      }
+    } else {
+      this._store.clear();
+    }
+  }
+
+  /**
+   * Gets all keys (without prefix)
+   * @returns {Promise<string[]>} Array of keys
+   */
+  async keys() {
+    const result = [];
+    const prefix = this._options.prefix ? `${this._options.prefix}:` : '';
+
+    for (const key of this._store.keys()) {
+      if (!prefix || key.startsWith(prefix)) {
+        const unprefixedKey = prefix ? key.slice(prefix.length) : key;
+        // Check expiration before including
+        const item = this._store.get(key);
+        if (!item.expiresAt || Date.now() <= item.expiresAt) {
+          result.push(unprefixedKey);
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Gets the current size of the storage
+   * @returns {Promise<number>} Number of stored items
+   */
+  async size() {
+    // Clean up expired items first
+    await this._cleanupExpired();
+    return (await this.keys()).length;
+  }
+
+  /**
+   * Cleans up expired items
+   * @returns {Promise<number>} Number of items removed
+   * @private
+   */
+  async _cleanupExpired() {
+    const now = Date.now();
+    let removed = 0;
+
+    for (const [key, item] of this._store.entries()) {
+      if (item.expiresAt && now > item.expiresAt) {
+        this._store.delete(key);
+        removed++;
+      }
+    }
+
+    return removed;
+  }
+
+  /**
+   * Gets all entries as an array of [key, value] pairs
+   * @returns {Promise<Array>} Array of [key, value] entries
+   */
+  async entries() {
+    const allKeys = await this.keys();
+    const result = [];
+
+    for (const key of allKeys) {
+      const value = await this.get(key);
+      if (value !== undefined) {
+        result.push([key, value]);
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Gets all values
+   * @returns {Promise<any[]>} Array of values
+   */
+  async values() {
+    const allEntries = await this.entries();
+    return allEntries.map(([, value]) => value);
+  }
+}
+
+module.exports = MemoryStorage;