@switchbot/homebridge-switchbot 5.0.0-beta.8 → 5.0.0-beta.80

package/src/switchbotClient.ts

@@ -0,0 +1,203 @@
+import type { SwitchBotPluginConfig } from './settings.js'
+
+export interface ISwitchBotClient {
+  init(): Promise<void>
+  getDevice(id: string): Promise<any>
+  getDevices(): Promise<any[]>
+  setDeviceState(id: string, body: any): Promise<any>
+  destroy(): Promise<void>
+}
+
+/**
+ * Thin wrapper around node-switchbot v4.0.0-beta.2+
+ * Leverages upstream resilience features (retry, circuit breaker, connection intelligence)
+ * while maintaining plugin-specific features like write debouncing and OpenAPI fallback.
+ */
+export class SwitchBotClient implements ISwitchBotClient {
+  private cfg: SwitchBotPluginConfig
+  private client: any | null = null
+  private baseUrl = 'https://api.switch-bot.com/v1.0'
+  private requestTimeout = 5000
+  private maxRetries = 2
+  private writeDebounceMs = 100
+  private logger: any
+  private pendingWrites: Map<string, { timer: any; body: any; resolvers: Array<{ resolve: (v:any)=>void; reject: (e:any)=>void }>; }> = new Map()
+
+  constructor(cfg: SwitchBotPluginConfig) {
+    this.cfg = cfg
+    this.logger = (cfg as any)?.logger ?? console
+    if (typeof (cfg as any)?.requestTimeout === 'number') this.requestTimeout = (cfg as any).requestTimeout
+    if (typeof (cfg as any)?.maxRetries === 'number') this.maxRetries = (cfg as any).maxRetries
+    if (typeof (cfg as any)?.writeDebounceMs === 'number') this.writeDebounceMs = (cfg as any).writeDebounceMs
+  }
+
+  async init(): Promise<void> {
+    try {
+      // Dynamic import of node-switchbot v4 with native resilience features
+      const { SwitchBot } = await import('node-switchbot')
+      this.client = new SwitchBot({
+        token: this.cfg.openApiToken,
+        secret: this.cfg.openApiSecret,
+        // Enable all built-in resilience features from node-switchbot v4
+        enableFallback: true,        // Auto-fallback from BLE to API
+        enableRetry: true,            // Retry with exponential backoff
+        enableCircuitBreaker: true,   // Circuit breaker per connection type
+        enableMetrics: true,          // Connection tracking and statistics
+        ...(typeof (this.cfg as any)?.nodeClientConfig === 'object' && (this.cfg as any).nodeClientConfig),
+      })
+      this.logger?.info?.('SwitchBot client initialized with native resilience features')
+    } catch (e) {
+      this.logger?.warn?.('Failed to load node-switchbot; will use OpenAPI fallback:', e)
+      this.client = null
+    }
+  }
+
+  private async fetchWithTimeoutAndRetry(url: string, opts: any = {}, timeoutMs?: number, retries?: number) {
+    const to = typeof timeoutMs === 'number' ? timeoutMs : this.requestTimeout
+    const max = typeof retries === 'number' ? retries : this.maxRetries
+
+    let attempt = 0
+    while (true) {
+      attempt += 1
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), to)
+      try {
+        const fetchOpts = Object.assign({}, opts)
+        try {
+          Object.defineProperty(fetchOpts, 'signal', { value: controller.signal, enumerable: false, configurable: true })
+        } catch (_e) {
+          // ignore
+        }
+        const resp = await fetch(url, fetchOpts)
+        clearTimeout(timer)
+        if (resp.ok) return resp
+        // server error / rate limit: retry
+        if (resp.status >= 500 || resp.status === 429) {
+          throw new Error(`retriable response: ${resp.status}`)
+        }
+        return resp
+      } catch (err: any) {
+        clearTimeout(timer)
+        if (attempt > max) throw err
+        // exponential backoff
+        const backoff = Math.min(100 * Math.pow(2, attempt - 1), 2000)
+        await new Promise((r) => setTimeout(r, backoff))
+      }
+    }
+  }
+
+  async getDevice(id: string): Promise<any> {
+    // Try client API first (with node-switchbot's smart fallback and retry)
+    if (this.client?.getDevice) {
+      try {
+        return await this.client.getDevice(id)
+      } catch (e) {
+        this.logger?.warn?.(`Client getDevice failed for ${id}, trying OpenAPI fallback:`, e)
+      }
+    }
+    // Fallback: call OpenAPI via HTTP
+    if (this.cfg.openApiToken) {
+      const url = `${this.baseUrl}/devices/${id}`
+      const opts = { headers: { Authorization: this.cfg.openApiToken } }
+      const resp = await this.fetchWithTimeoutAndRetry(url, opts)
+      return resp.json()
+    }
+    throw new Error('No SwitchBot client available')
+  }
+
+  async getDevices(): Promise<any[]> {
+    // Try client API first
+    if (this.client?.getDevices) {
+      try {
+        return await this.client.getDevices()
+      } catch (e) {
+        this.logger?.warn?.('Client getDevices failed, trying OpenAPI fallback:', e)
+      }
+    }
+    // Fallback: call OpenAPI
+    if (this.cfg.openApiToken) {
+      const url = `${this.baseUrl}/devices`
+      const opts = { headers: { Authorization: this.cfg.openApiToken } }
+      const resp = await this.fetchWithTimeoutAndRetry(url, opts)
+      const data = await resp.json()
+      return (data?.body || data) as any[]
+    }
+    return []
+  }
+
+  async setDeviceState(id: string, body: any): Promise<any> {
+    // Plugin-level debounce: coalesce rapid writes per device
+    if (!this.writeDebounceMs || this.writeDebounceMs <= 0) {
+      return this._doSetDeviceState(id, body)
+    }
+
+    return new Promise((resolve, reject) => {
+      const existing = this.pendingWrites.get(id)
+      if (existing) {
+        existing.body = body
+        existing.resolvers.push({ resolve, reject })
+        return
+      }
+
+      const resolvers: Array<{ resolve: (v:any)=>void; reject: (e:any)=>void }> = [{ resolve, reject }]
+      const timer = setTimeout(async () => {
+        const entry = this.pendingWrites.get(id)
+        if (!entry) return
+        this.pendingWrites.delete(id)
+        try {
+          const out = await this._doSetDeviceState(id, entry.body)
+          for (const r of entry.resolvers) r.resolve(out)
+        } catch (e) {
+          for (const r of entry.resolvers) r.reject(e)
+        }
+      }, this.writeDebounceMs)
+
+      this.pendingWrites.set(id, { timer, body, resolvers })
+    })
+  }
+
+  private async _doSetDeviceState(id: string, body: any): Promise<any> {
+    // Prefer client API (which has node-switchbot's native resilience)
+    if (this.client?.setDeviceState) {
+      try {
+        return await this.client.setDeviceState(id, body)
+      } catch (e) {
+        this.logger?.warn?.(`Client setDeviceState failed for ${id}, trying fallback:`, e)
+      }
+    }
+
+    // Try generic sendCommand if available
+    if (this.client?.sendCommand) {
+      try {
+        return await this.client.sendCommand(id, body)
+      } catch (e) {
+        this.logger?.warn?.(`Client sendCommand failed for ${id}, trying OpenAPI:`, e)
+      }
+    }
+
+    // OpenAPI fallback
+    if (this.cfg.openApiToken) {
+      const url = `${this.baseUrl}/devices/${id}/commands`
+      const opts = {
+        method: 'POST',
+        headers: {
+          Authorization: this.cfg.openApiToken,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      }
+      const resp = await this.fetchWithTimeoutAndRetry(url, opts)
+      return resp.json()
+    }
+
+    throw new Error('No SwitchBot client available for setDeviceState')
+  }
+
+  async destroy(): Promise<void> {
+    if (this.client?.destroy) {
+      await this.client.destroy()
+    }
+    this.client = null
+  }
+}
+