react-native-ble-mesh 1.0.1

package/src/storage/MessageStore.js

@@ -0,0 +1,315 @@
+'use strict';
+
+/**
+ * @fileoverview Message persistence layer for BLE Mesh Network
+ * @module storage/MessageStore
+ */
+
+const MemoryStorage = require('./MemoryStorage');
+const { MESH_CONFIG } = require('../constants');
+
+/**
+ * Message store for persisting and retrieving mesh network messages.
+ * Provides message caching, deduplication support, and cleanup functionality.
+ *
+ * @class MessageStore
+ */
+class MessageStore {
+  /**
+   * Creates a new MessageStore instance
+   * @param {Object} [options={}] - Store options
+   * @param {Object} [options.storage] - Storage backend (defaults to MemoryStorage)
+   * @param {number} [options.maxMessages=1000] - Maximum messages to store
+   * @param {number} [options.messageTtlMs] - Message TTL in milliseconds
+   */
+  constructor(options = {}) {
+    /**
+     * Storage backend
+     * @type {Object}
+     * @private
+     */
+    this._storage = options.storage || new MemoryStorage({
+      prefix: 'msg',
+      maxSize: options.maxMessages || 1000
+    });
+
+    /**
+     * Message TTL in milliseconds
+     * @type {number}
+     * @private
+     */
+    this._messageTtlMs = options.messageTtlMs || MESH_CONFIG.MESSAGE_TTL_MS;
+
+    /**
+     * Index storage for queries
+     * @type {Object}
+     * @private
+     */
+    this._indexStorage = options.indexStorage || new MemoryStorage({
+      prefix: 'msg_idx'
+    });
+  }
+
+  /**
+   * Saves a message to storage
+   * @param {Object} message - Message to save
+   * @param {string} message.id - Message ID
+   * @param {number} message.type - Message type
+   * @param {Uint8Array} [message.payload] - Message payload
+   * @param {string} [message.senderId] - Sender peer ID
+   * @param {string} [message.recipientId] - Recipient peer ID
+   * @param {number} [message.timestamp] - Message timestamp
+   * @returns {Promise<void>}
+   */
+  async saveMessage(message) {
+    if (!message || !message.id) {
+      throw new Error('Message must have an id');
+    }
+
+    const storedMessage = {
+      ...message,
+      payload: message.payload
+        ? Array.from(message.payload)
+        : undefined,
+      storedAt: Date.now()
+    };
+
+    await this._storage.set(message.id, storedMessage, {
+      ttl: this._messageTtlMs
+    });
+
+    // Update indexes
+    await this._updateIndexes(storedMessage);
+  }
+
+  /**
+   * Gets a message by ID
+   * @param {string} id - Message ID
+   * @returns {Promise<Object|null>} Message or null if not found
+   */
+  async getMessage(id) {
+    const message = await this._storage.get(id);
+
+    if (!message) {
+      return null;
+    }
+
+    // Convert payload back to Uint8Array
+    if (message.payload) {
+      message.payload = new Uint8Array(message.payload);
+    }
+
+    return message;
+  }
+
+  /**
+   * Gets messages matching query options
+   * @param {Object} [options={}] - Query options
+   * @param {string} [options.senderId] - Filter by sender ID
+   * @param {string} [options.recipientId] - Filter by recipient ID
+   * @param {number} [options.type] - Filter by message type
+   * @param {number} [options.since] - Filter messages since timestamp
+   * @param {number} [options.until] - Filter messages until timestamp
+   * @param {number} [options.limit=50] - Maximum messages to return
+   * @param {number} [options.offset=0] - Offset for pagination
+   * @returns {Promise<Object[]>} Array of messages
+   */
+  async getMessages(options = {}) {
+    const {
+      senderId,
+      recipientId,
+      type,
+      since,
+      until,
+      limit = 50,
+      offset = 0
+    } = options;
+
+    const allKeys = await this._storage.keys();
+    const messages = [];
+
+    for (const key of allKeys) {
+      const message = await this.getMessage(key);
+      if (!message) { continue; }
+
+      // Apply filters
+      if (senderId && message.senderId !== senderId) { continue; }
+      if (recipientId && message.recipientId !== recipientId) { continue; }
+      if (type !== undefined && message.type !== type) { continue; }
+      if (since && message.timestamp < since) { continue; }
+      if (until && message.timestamp > until) { continue; }
+
+      messages.push(message);
+    }
+
+    // Sort by timestamp (newest first)
+    messages.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+
+    // Apply pagination
+    return messages.slice(offset, offset + limit);
+  }
+
+  /**
+   * Deletes a message by ID
+   * @param {string} id - Message ID
+   * @returns {Promise<void>}
+   */
+  async deleteMessage(id) {
+    const message = await this.getMessage(id);
+    if (message) {
+      await this._removeFromIndexes(message);
+    }
+    await this._storage.delete(id);
+  }
+
+  /**
+   * Checks if a message exists
+   * @param {string} id - Message ID
+   * @returns {Promise<boolean>} True if message exists
+   */
+  async hasMessage(id) {
+    return this._storage.has(id);
+  }
+
+  /**
+   * Cleans up expired messages
+   * @param {number} [maxAgeMs] - Maximum message age in milliseconds
+   * @returns {Promise<number>} Number of messages removed
+   */
+  async cleanup(maxAgeMs) {
+    const maxAge = maxAgeMs || this._messageTtlMs;
+    const cutoff = Date.now() - maxAge;
+    const allKeys = await this._storage.keys();
+    let removed = 0;
+
+    for (const key of allKeys) {
+      const message = await this._storage.get(key);
+      if (message) {
+        const messageTime = message.timestamp || message.storedAt || 0;
+        if (messageTime < cutoff) {
+          await this.deleteMessage(key);
+          removed++;
+        }
+      }
+    }
+
+    return removed;
+  }
+
+  /**
+   * Gets the count of stored messages
+   * @returns {Promise<number>} Number of messages
+   */
+  async getCount() {
+    return this._storage.size();
+  }
+
+  /**
+   * Clears all stored messages
+   * @returns {Promise<void>}
+   */
+  async clear() {
+    await this._storage.clear();
+    await this._indexStorage.clear();
+  }
+
+  /**
+   * Gets messages by sender
+   * @param {string} senderId - Sender peer ID
+   * @param {number} [limit=50] - Maximum messages
+   * @returns {Promise<Object[]>} Array of messages
+   */
+  async getMessagesBySender(senderId, limit = 50) {
+    return this.getMessages({ senderId, limit });
+  }
+
+  /**
+   * Gets messages by recipient
+   * @param {string} recipientId - Recipient peer ID
+   * @param {number} [limit=50] - Maximum messages
+   * @returns {Promise<Object[]>} Array of messages
+   */
+  async getMessagesByRecipient(recipientId, limit = 50) {
+    return this.getMessages({ recipientId, limit });
+  }
+
+  /**
+   * Gets conversation messages between two peers
+   * @param {string} peerId1 - First peer ID
+   * @param {string} peerId2 - Second peer ID
+   * @param {number} [limit=50] - Maximum messages
+   * @returns {Promise<Object[]>} Array of messages
+   */
+  async getConversation(peerId1, peerId2, limit = 50) {
+    const allKeys = await this._storage.keys();
+    const messages = [];
+
+    for (const key of allKeys) {
+      const message = await this.getMessage(key);
+      if (!message) { continue; }
+
+      const isMatch =
+        (message.senderId === peerId1 && message.recipientId === peerId2) ||
+        (message.senderId === peerId2 && message.recipientId === peerId1);
+
+      if (isMatch) {
+        messages.push(message);
+      }
+    }
+
+    messages.sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+    return messages.slice(-limit);
+  }
+
+  /**
+   * Updates indexes for a message
+   * @param {Object} message - Message to index
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _updateIndexes(message) {
+    // Sender index
+    if (message.senderId) {
+      const key = `sender:${message.senderId}`;
+      const ids = (await this._indexStorage.get(key)) || [];
+      if (!ids.includes(message.id)) {
+        ids.push(message.id);
+        await this._indexStorage.set(key, ids);
+      }
+    }
+
+    // Recipient index
+    if (message.recipientId) {
+      const key = `recipient:${message.recipientId}`;
+      const ids = (await this._indexStorage.get(key)) || [];
+      if (!ids.includes(message.id)) {
+        ids.push(message.id);
+        await this._indexStorage.set(key, ids);
+      }
+    }
+  }
+
+  /**
+   * Removes a message from indexes
+   * @param {Object} message - Message to remove from indexes
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _removeFromIndexes(message) {
+    if (message.senderId) {
+      const key = `sender:${message.senderId}`;
+      const ids = (await this._indexStorage.get(key)) || [];
+      const filtered = ids.filter(id => id !== message.id);
+      await this._indexStorage.set(key, filtered);
+    }
+
+    if (message.recipientId) {
+      const key = `recipient:${message.recipientId}`;
+      const ids = (await this._indexStorage.get(key)) || [];
+      const filtered = ids.filter(id => id !== message.id);
+      await this._indexStorage.set(key, filtered);
+    }
+  }
+}
+
+module.exports = MessageStore;

package/src/storage/Storage.js

@@ -0,0 +1,160 @@
+'use strict';
+
+/**
+ * @fileoverview Abstract storage interface for BLE Mesh Network
+ * @module storage/Storage
+ */
+
+/**
+ * Abstract storage interface.
+ * Extend this class to implement specific storage backends.
+ *
+ * @abstract
+ * @class Storage
+ */
+class Storage {
+  /**
+   * Creates a new Storage instance
+   * @param {Object} [options={}] - Storage options
+   * @param {string} [options.prefix=''] - Key prefix for namespacing
+   */
+  constructor(options = {}) {
+    /**
+     * Storage options
+     * @type {Object}
+     * @protected
+     */
+    this._options = {
+      prefix: '',
+      ...options
+    };
+  }
+
+  /**
+   * Gets the prefixed key
+   * @param {string} key - Original key
+   * @returns {string} Prefixed key
+   * @protected
+   */
+  _getKey(key) {
+    return this._options.prefix ? `${this._options.prefix}:${key}` : key;
+  }
+
+  /**
+   * Gets a value by key
+   * @abstract
+   * @param {string} key - Key to retrieve
+   * @returns {Promise<any>} Stored value or undefined
+   * @throws {Error} If not implemented by subclass
+   */
+  async get(_key) {
+    throw new Error('Storage.get() must be implemented by subclass');
+  }
+
+  /**
+   * Sets a value by key
+   * @abstract
+   * @param {string} key - Key to set
+   * @param {any} value - Value to store
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async set(_key, _value) {
+    throw new Error('Storage.set() must be implemented by subclass');
+  }
+
+  /**
+   * Deletes a value by key
+   * @abstract
+   * @param {string} key - Key to delete
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async delete(_key) {
+    throw new Error('Storage.delete() must be implemented by subclass');
+  }
+
+  /**
+   * Checks if a key exists
+   * @abstract
+   * @param {string} key - Key to check
+   * @returns {Promise<boolean>} True if key exists
+   * @throws {Error} If not implemented by subclass
+   */
+  async has(_key) {
+    throw new Error('Storage.has() must be implemented by subclass');
+  }
+
+  /**
+   * Clears all stored data
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async clear() {
+    throw new Error('Storage.clear() must be implemented by subclass');
+  }
+
+  /**
+   * Gets all keys
+   * @abstract
+   * @returns {Promise<string[]>} Array of keys
+   * @throws {Error} If not implemented by subclass
+   */
+  async keys() {
+    throw new Error('Storage.keys() must be implemented by subclass');
+  }
+
+  /**
+   * Gets the number of stored items
+   * @returns {Promise<number>} Number of items
+   */
+  async size() {
+    const allKeys = await this.keys();
+    return allKeys.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) {
+    const result = new Map();
+    await Promise.all(
+      keys.map(async (key) => {
+        const value = await this.get(key);
+        if (value !== undefined) {
+          result.set(key, value);
+        }
+      })
+    );
+    return result;
+  }
+
+  /**
+   * Sets multiple key-value pairs
+   * @param {Map<string, any>|Object} entries - Entries to set
+   * @returns {Promise<void>}
+   */
+  async setMany(entries) {
+    const pairs = entries instanceof Map
+      ? Array.from(entries.entries())
+      : Object.entries(entries);
+
+    await Promise.all(
+      pairs.map(([key, value]) => this.set(key, value))
+    );
+  }
+
+  /**
+   * Deletes multiple keys
+   * @param {string[]} keys - Keys to delete
+   * @returns {Promise<void>}
+   */
+  async deleteMany(keys) {
+    await Promise.all(keys.map(key => this.delete(key)));
+  }
+}
+
+module.exports = Storage;

package/src/storage/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/**
+ * @fileoverview Storage module exports
+ * @module storage
+ */
+
+const Storage = require('./Storage');
+const MemoryStorage = require('./MemoryStorage');
+const AsyncStorageAdapter = require('./AsyncStorageAdapter');
+const MessageStore = require('./MessageStore');
+
+module.exports = {
+  Storage,
+  MemoryStorage,
+  AsyncStorageAdapter,
+  MessageStore
+};

package/src/transport/BLEAdapter.js

@@ -0,0 +1,177 @@
+'use strict';
+
+/**
+ * @fileoverview Abstract BLE adapter interface
+ * @module transport/BLEAdapter
+ */
+
+const { BLUETOOTH_STATE } = require('../constants');
+
+/**
+ * Abstract BLE adapter interface.
+ * Provides a unified API for different BLE implementations.
+ *
+ * @abstract
+ * @class BLEAdapter
+ */
+class BLEAdapter {
+  /**
+   * Creates a new BLEAdapter instance
+   * @param {Object} [options={}] - Adapter options
+   */
+  constructor(options = {}) {
+    /**
+     * Adapter options
+     * @type {Object}
+     * @protected
+     */
+    this._options = options;
+
+    /**
+     * State change callback
+     * @type {Function|null}
+     * @protected
+     */
+    this._stateChangeCallback = null;
+
+    /**
+     * Whether adapter is initialized
+     * @type {boolean}
+     * @protected
+     */
+    this._initialized = false;
+  }
+
+  /**
+   * Gets whether the adapter is initialized
+   * @returns {boolean} True if initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+
+  /**
+   * Initializes the BLE adapter
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async initialize() {
+    throw new Error('BLEAdapter.initialize() must be implemented by subclass');
+  }
+
+  /**
+   * Destroys the BLE adapter and releases resources
+   * @abstract
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async destroy() {
+    throw new Error('BLEAdapter.destroy() must be implemented by subclass');
+  }
+
+  /**
+   * Starts scanning for BLE devices
+   * @abstract
+   * @param {string[]} serviceUUIDs - Service UUIDs to filter by
+   * @param {Function} callback - Callback for discovered devices
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async startScan(_serviceUUIDs, _callback) {
+    throw new Error('BLEAdapter.startScan() must be implemented by subclass');
+  }
+
+  /**
+   * Stops scanning for BLE devices
+   * @abstract
+   * @throws {Error} If not implemented by subclass
+   */
+  stopScan() {
+    throw new Error('BLEAdapter.stopScan() must be implemented by subclass');
+  }
+
+  /**
+   * Connects to a BLE device
+   * @abstract
+   * @param {string} deviceId - Device ID to connect to
+   * @returns {Promise<Object>} Connected device info
+   * @throws {Error} If not implemented by subclass
+   */
+  async connect(_deviceId) {
+    throw new Error('BLEAdapter.connect() must be implemented by subclass');
+  }
+
+  /**
+   * Disconnects from a BLE device
+   * @abstract
+   * @param {string} deviceId - Device ID to disconnect from
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async disconnect(_deviceId) {
+    throw new Error('BLEAdapter.disconnect() must be implemented by subclass');
+  }
+
+  /**
+   * Writes data to a characteristic
+   * @abstract
+   * @param {string} deviceId - Target device ID
+   * @param {string} serviceUUID - Service UUID
+   * @param {string} charUUID - Characteristic UUID
+   * @param {Uint8Array} data - Data to write
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async write(_deviceId, _serviceUUID, _charUUID, _data) {
+    throw new Error('BLEAdapter.write() must be implemented by subclass');
+  }
+
+  /**
+   * Subscribes to characteristic notifications
+   * @abstract
+   * @param {string} deviceId - Target device ID
+   * @param {string} serviceUUID - Service UUID
+   * @param {string} charUUID - Characteristic UUID
+   * @param {Function} callback - Notification callback
+   * @returns {Promise<void>}
+   * @throws {Error} If not implemented by subclass
+   */
+  async subscribe(_deviceId, _serviceUUID, _charUUID, _callback) {
+    throw new Error('BLEAdapter.subscribe() must be implemented by subclass');
+  }
+
+  /**
+   * Gets the current Bluetooth state
+   * @abstract
+   * @returns {Promise<string>} Bluetooth state
+   * @throws {Error} If not implemented by subclass
+   */
+  async getState() {
+    throw new Error('BLEAdapter.getState() must be implemented by subclass');
+  }
+
+  /**
+   * Registers a callback for Bluetooth state changes
+   * @param {Function} callback - State change callback
+   */
+  onStateChange(callback) {
+    this._stateChangeCallback = callback;
+  }
+
+  /**
+   * Notifies listeners of state change
+   * @param {string} state - New Bluetooth state
+   * @protected
+   */
+  _notifyStateChange(state) {
+    if (this._stateChangeCallback) {
+      this._stateChangeCallback(state);
+    }
+  }
+}
+
+// Export state constants with the class
+BLEAdapter.STATE = BLUETOOTH_STATE;
+
+module.exports = BLEAdapter;