react-native-ble-mesh 1.0.1

package/src/mesh/router/PathFinder.js

@@ -0,0 +1,332 @@
+'use strict';
+
+/**
+ * @fileoverview Route discovery and path finding logic
+ * @module mesh/router/PathFinder
+ */
+
+const EventEmitter = require('events');
+const { MESH_CONFIG } = require('../../constants');
+const { ValidationError } = require('../../errors');
+
+/**
+ * Route request entry
+ * @typedef {Object} RouteRequest
+ * @property {string} requestId - Unique request ID
+ * @property {string} destination - Target peer ID
+ * @property {number} createdAt - Request creation timestamp
+ * @property {number} expiresAt - Request expiration timestamp
+ * @property {Function} resolve - Promise resolve function
+ * @property {Function} reject - Promise reject function
+ */
+
+/**
+ * Path finder for route discovery
+ * @class PathFinder
+ * @extends EventEmitter
+ */
+class PathFinder extends EventEmitter {
+  /**
+   * Creates a new PathFinder
+   * @param {Object} options - Configuration options
+   * @param {string} options.localPeerId - Local peer ID
+   * @param {Object} options.routeTable - RouteTable instance
+   * @param {number} [options.discoveryTimeout] - Route discovery timeout
+   */
+  constructor(options = {}) {
+    super();
+
+    if (!options.localPeerId) {
+      throw ValidationError.missingArgument('localPeerId');
+    }
+    if (!options.routeTable) {
+      throw ValidationError.missingArgument('routeTable');
+    }
+
+    /**
+     * Local peer ID
+     * @type {string}
+     */
+    this.localPeerId = options.localPeerId;
+
+    /**
+     * Route table reference
+     * @type {Object}
+     */
+    this.routeTable = options.routeTable;
+
+    /**
+     * Discovery timeout in milliseconds
+     * @type {number}
+     */
+    this.discoveryTimeout = options.discoveryTimeout || 10000;
+
+    /**
+     * Pending route requests
+     * @type {Map<string, RouteRequest>}
+     * @private
+     */
+    this._pendingRequests = new Map();
+
+    /**
+     * Request counter for unique IDs
+     * @type {number}
+     * @private
+     */
+    this._requestCounter = 0;
+
+    /**
+     * Statistics
+     * @type {Object}
+     * @private
+     */
+    this._stats = {
+      requestsSent: 0,
+      requestsReceived: 0,
+      repliesSent: 0,
+      repliesReceived: 0,
+      routesDiscovered: 0,
+      requestsTimedOut: 0
+    };
+  }
+
+  /**
+   * Finds a route to a destination
+   * @param {string} destination - Target peer ID
+   * @returns {Promise<Object|null>} Route or null if not found
+   */
+  async findRoute(destination) {
+    if (!destination || typeof destination !== 'string') {
+      throw ValidationError.invalidArgument('destination', destination);
+    }
+
+    // Check existing route first
+    const existingRoute = this.routeTable.getRoute(destination);
+    if (existingRoute) {
+      return existingRoute;
+    }
+
+    // Initiate route discovery
+    return this._initiateDiscovery(destination);
+  }
+
+  /**
+   * Initiates route discovery for a destination
+   * @param {string} destination - Target peer ID
+   * @returns {Promise<Object|null>} Discovered route or null
+   * @private
+   */
+  _initiateDiscovery(destination) {
+    return new Promise((resolve, reject) => {
+      const requestId = this._generateRequestId();
+      const now = Date.now();
+
+      const request = {
+        requestId,
+        destination,
+        createdAt: now,
+        expiresAt: now + this.discoveryTimeout,
+        resolve,
+        reject
+      };
+
+      this._pendingRequests.set(requestId, request);
+      this._stats.requestsSent++;
+
+      // Emit discovery request event
+      this.emit('discovery:request', {
+        requestId,
+        destination,
+        sourcePeerId: this.localPeerId,
+        hopCount: 0
+      });
+
+      // Set timeout
+      setTimeout(() => {
+        if (this._pendingRequests.has(requestId)) {
+          this._pendingRequests.delete(requestId);
+          this._stats.requestsTimedOut++;
+          resolve(null);
+        }
+      }, this.discoveryTimeout);
+    });
+  }
+
+  /**
+   * Generates a unique request ID
+   * @returns {string} Request ID
+   * @private
+   */
+  _generateRequestId() {
+    this._requestCounter = (this._requestCounter + 1) % 0xFFFFFFFF;
+    return `${this.localPeerId}:${this._requestCounter}:${Date.now()}`;
+  }
+
+  /**
+   * Processes an incoming route request
+   * @param {Object} request - Route request data
+   * @param {string} sourcePeerId - Source peer ID
+   * @returns {Object|null} Reply to send or null
+   */
+  processRouteRequest(request, sourcePeerId) {
+    this._stats.requestsReceived++;
+
+    const { requestId, destination, hopCount = 0 } = request;
+
+    // Ignore requests for ourselves
+    if (request.sourcePeerId === this.localPeerId) {
+      return null;
+    }
+
+    // Check if we are the destination
+    if (destination === this.localPeerId) {
+      this._stats.repliesSent++;
+      return {
+        type: 'route:reply',
+        requestId,
+        destination,
+        nextHop: this.localPeerId,
+        hopCount: 0,
+        success: true
+      };
+    }
+
+    // Check if we have a route
+    const route = this.routeTable.getRoute(destination);
+    if (route) {
+      this._stats.repliesSent++;
+      return {
+        type: 'route:reply',
+        requestId,
+        destination,
+        nextHop: this.localPeerId,
+        hopCount: route.hopCount + 1,
+        success: true
+      };
+    }
+
+    // Forward the request if within hop limit
+    if (hopCount < MESH_CONFIG.MAX_HOPS) {
+      this.emit('discovery:forward', {
+        ...request,
+        hopCount: hopCount + 1,
+        previousHop: sourcePeerId
+      });
+    }
+
+    return null;
+  }
+
+  /**
+   * Processes an incoming route reply
+   * @param {Object} reply - Route reply data
+   * @param {string} sourcePeerId - Source peer ID
+   */
+  processRouteReply(reply, sourcePeerId) {
+    this._stats.repliesReceived++;
+
+    const { requestId, destination, hopCount, success } = reply;
+    const pendingRequest = this._pendingRequests.get(requestId);
+
+    if (!pendingRequest) {
+      // Not our request, may need to forward
+      return;
+    }
+
+    this._pendingRequests.delete(requestId);
+
+    if (success) {
+      // Add route to table
+      this.routeTable.addRoute(destination, sourcePeerId, hopCount + 1);
+      this._stats.routesDiscovered++;
+
+      const route = this.routeTable.getRoute(destination);
+      pendingRequest.resolve(route);
+    } else {
+      pendingRequest.resolve(null);
+    }
+  }
+
+  /**
+   * Updates route information from received messages
+   * @param {string} sourcePeerId - Source peer ID
+   * @param {string} originalSender - Original message sender
+   * @param {number} hopCount - Current hop count
+   */
+  updateRouteFromMessage(sourcePeerId, originalSender, hopCount) {
+    // Add/update route to original sender via source peer
+    if (originalSender !== this.localPeerId) {
+      this.routeTable.addRoute(originalSender, sourcePeerId, hopCount);
+    }
+
+    // Direct neighbor
+    if (sourcePeerId !== this.localPeerId) {
+      this.routeTable.addRoute(sourcePeerId, sourcePeerId, 0);
+    }
+  }
+
+  /**
+   * Gets pending request count
+   * @returns {number} Number of pending requests
+   */
+  getPendingCount() {
+    return this._pendingRequests.size;
+  }
+
+  /**
+   * Cleans up expired requests
+   * @returns {number} Number of cleaned up requests
+   */
+  cleanup() {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [requestId, request] of this._pendingRequests) {
+      if (now > request.expiresAt) {
+        request.resolve(null);
+        this._pendingRequests.delete(requestId);
+        this._stats.requestsTimedOut++;
+        cleaned++;
+      }
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Gets path finder statistics
+   * @returns {Object} Statistics
+   */
+  getStats() {
+    return {
+      ...this._stats,
+      pendingRequests: this._pendingRequests.size
+    };
+  }
+
+  /**
+   * Resets statistics
+   */
+  resetStats() {
+    this._stats = {
+      requestsSent: 0,
+      requestsReceived: 0,
+      repliesSent: 0,
+      repliesReceived: 0,
+      routesDiscovered: 0,
+      requestsTimedOut: 0
+    };
+  }
+
+  /**
+   * Clears all pending requests
+   */
+  clear() {
+    for (const request of this._pendingRequests.values()) {
+      request.resolve(null);
+    }
+    this._pendingRequests.clear();
+  }
+}
+
+module.exports = PathFinder;

package/src/mesh/router/RouteTable.js

@@ -0,0 +1,292 @@
+'use strict';
+
+/**
+ * @fileoverview Routing table for mesh network
+ * @module mesh/router/RouteTable
+ */
+
+const { MESH_CONFIG } = require('../../constants');
+const { ValidationError } = require('../../errors');
+
+/**
+ * Route entry
+ * @typedef {Object} RouteEntry
+ * @property {string} destination - Destination peer ID
+ * @property {string} nextHop - Next hop peer ID
+ * @property {number} hopCount - Distance in hops
+ * @property {number} metric - Route quality metric
+ * @property {number} lastUpdated - Last update timestamp
+ * @property {number} expiresAt - Expiration timestamp
+ */
+
+/**
+ * Routing table for tracking paths to peers
+ * @class RouteTable
+ */
+class RouteTable {
+  /**
+   * Creates a new RouteTable
+   * @param {Object} [options] - Configuration options
+   * @param {number} [options.routeTimeout] - Route expiration timeout
+   * @param {number} [options.maxRoutes] - Maximum routes to store
+   */
+  constructor(options = {}) {
+    /**
+     * Route timeout in milliseconds
+     * @type {number}
+     */
+    this.routeTimeout = options.routeTimeout || MESH_CONFIG.ROUTE_TIMEOUT_MS;
+
+    /**
+     * Maximum routes to store
+     * @type {number}
+     */
+    this.maxRoutes = options.maxRoutes || 256;
+
+    /**
+     * Routes by destination peer ID
+     * @type {Map<string, RouteEntry>}
+     * @private
+     */
+    this._routes = new Map();
+
+    /**
+     * Direct neighbors (next hop = destination)
+     * @type {Set<string>}
+     * @private
+     */
+    this._neighbors = new Set();
+  }
+
+  /**
+   * Adds or updates a route
+   * @param {string} destination - Destination peer ID
+   * @param {string} nextHop - Next hop peer ID
+   * @param {number} hopCount - Hop count to destination
+   * @param {number} [metric] - Quality metric (lower is better)
+   * @returns {boolean} True if route was added/updated
+   */
+  addRoute(destination, nextHop, hopCount, metric = 0) {
+    if (!destination || typeof destination !== 'string') {
+      throw ValidationError.invalidArgument('destination', destination);
+    }
+    if (!nextHop || typeof nextHop !== 'string') {
+      throw ValidationError.invalidArgument('nextHop', nextHop);
+    }
+    if (!Number.isInteger(hopCount) || hopCount < 0) {
+      throw ValidationError.outOfRange('hopCount', hopCount, { min: 0 });
+    }
+
+    const existingRoute = this._routes.get(destination);
+    const now = Date.now();
+
+    // Check if we should update the route
+    if (existingRoute) {
+      // Prefer routes with fewer hops or better metric
+      const existingScore = existingRoute.hopCount * 100 + existingRoute.metric;
+      const newScore = hopCount * 100 + metric;
+
+      if (newScore >= existingScore && !existingRoute.isExpired) {
+        // Only update if same next hop (refresh)
+        if (existingRoute.nextHop === nextHop) {
+          existingRoute.lastUpdated = now;
+          existingRoute.expiresAt = now + this.routeTimeout;
+          return true;
+        }
+        return false;
+      }
+    }
+
+    // Enforce max routes limit
+    if (!existingRoute && this._routes.size >= this.maxRoutes) {
+      this._evictOldestRoute();
+    }
+
+    const route = {
+      destination,
+      nextHop,
+      hopCount,
+      metric,
+      lastUpdated: now,
+      expiresAt: now + this.routeTimeout
+    };
+
+    this._routes.set(destination, route);
+
+    // Track direct neighbors
+    if (hopCount === 0 || destination === nextHop) {
+      this._neighbors.add(destination);
+    }
+
+    return true;
+  }
+
+  /**
+   * Gets a route to a destination
+   * @param {string} destination - Destination peer ID
+   * @returns {RouteEntry|undefined} Route or undefined
+   */
+  getRoute(destination) {
+    const route = this._routes.get(destination);
+    if (!route) { return undefined; }
+
+    // Check if expired
+    if (Date.now() > route.expiresAt) {
+      this._routes.delete(destination);
+      this._neighbors.delete(destination);
+      return undefined;
+    }
+
+    return route;
+  }
+
+  /**
+   * Gets the next hop for a destination
+   * @param {string} destination - Destination peer ID
+   * @returns {string|null} Next hop peer ID or null
+   */
+  getNextHop(destination) {
+    const route = this.getRoute(destination);
+    return route ? route.nextHop : null;
+  }
+
+  /**
+   * Removes a route
+   * @param {string} destination - Destination peer ID
+   * @returns {boolean} True if removed
+   */
+  removeRoute(destination) {
+    const removed = this._routes.delete(destination);
+    if (removed) {
+      this._neighbors.delete(destination);
+    }
+    return removed;
+  }
+
+  /**
+   * Removes all routes through a specific next hop
+   * @param {string} nextHop - Next hop peer ID
+   * @returns {string[]} Removed destination IDs
+   */
+  removeRoutesVia(nextHop) {
+    const removed = [];
+    for (const [destination, route] of this._routes) {
+      if (route.nextHop === nextHop) {
+        this._routes.delete(destination);
+        this._neighbors.delete(destination);
+        removed.push(destination);
+      }
+    }
+    return removed;
+  }
+
+  /**
+   * Checks if a route exists
+   * @param {string} destination - Destination peer ID
+   * @returns {boolean} True if route exists and is valid
+   */
+  hasRoute(destination) {
+    return this.getRoute(destination) !== undefined;
+  }
+
+  /**
+   * Gets all valid routes
+   * @returns {RouteEntry[]} Array of routes
+   */
+  getAllRoutes() {
+    const now = Date.now();
+    const routes = [];
+
+    for (const [, route] of this._routes) {
+      if (now <= route.expiresAt) {
+        routes.push({ ...route });
+      }
+    }
+
+    return routes;
+  }
+
+  /**
+   * Gets all direct neighbors
+   * @returns {string[]} Array of neighbor peer IDs
+   */
+  getNeighbors() {
+    return Array.from(this._neighbors);
+  }
+
+  /**
+   * Cleans up expired routes
+   * @returns {string[]} Array of removed destination IDs
+   */
+  cleanup() {
+    const removed = [];
+    const now = Date.now();
+
+    for (const [destination, route] of this._routes) {
+      if (now > route.expiresAt) {
+        this._routes.delete(destination);
+        this._neighbors.delete(destination);
+        removed.push(destination);
+      }
+    }
+
+    return removed;
+  }
+
+  /**
+   * Evicts the oldest route
+   * @private
+   */
+  _evictOldestRoute() {
+    let oldest = null;
+    let oldestTime = Infinity;
+
+    for (const [destination, route] of this._routes) {
+      if (route.lastUpdated < oldestTime) {
+        oldest = destination;
+        oldestTime = route.lastUpdated;
+      }
+    }
+
+    if (oldest) {
+      this._routes.delete(oldest);
+      this._neighbors.delete(oldest);
+    }
+  }
+
+  /**
+   * Clears all routes
+   */
+  clear() {
+    this._routes.clear();
+    this._neighbors.clear();
+  }
+
+  /**
+   * Gets the number of routes
+   * @returns {number} Route count
+   */
+  get size() {
+    return this._routes.size;
+  }
+
+  /**
+   * Gets routing table statistics
+   * @returns {Object} Statistics
+   */
+  getStats() {
+    const routes = this.getAllRoutes();
+    const hopCounts = routes.map(r => r.hopCount);
+
+    return {
+      totalRoutes: routes.length,
+      directNeighbors: this._neighbors.size,
+      maxHops: hopCounts.length > 0 ? Math.max(...hopCounts) : 0,
+      avgHops: hopCounts.length > 0
+        ? hopCounts.reduce((a, b) => a + b, 0) / hopCounts.length
+        : 0
+    };
+  }
+}
+
+module.exports = RouteTable;

package/src/mesh/router/index.js

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Router module exports
+ * @module mesh/router
+ */
+
+'use strict';
+
+const RouteTable = require('./RouteTable');
+const PathFinder = require('./PathFinder');
+const MessageRouter = require('./MessageRouter');
+
+module.exports = {
+  RouteTable,
+  PathFinder,
+  MessageRouter
+};