@evops/lightwaverf 1.0.4 → 1.0.5

package/.dist/LightwaveCommandQueue.d.ts

@@ -0,0 +1,39 @@
+import { Debugger } from "debug";
+export interface QueuedTransaction {
+    id: number;
+    originalMessage: string;
+    message: string;
+    resolve: (value: TransactionResponse) => void;
+    reject: (error: Error) => void;
+    timeoutId?: ReturnType<typeof setTimeout>;
+    retryTimeoutId?: ReturnType<typeof setTimeout>;
+    delay: number;
+    completed: boolean;
+}
+export interface TransactionResponse {
+    id: number;
+    [key: string]: unknown;
+}
+export interface LightwaveCommandQueueOptions {
+    debug: Debugger;
+    delay?: number;
+    timeout?: number;
+    onExecute: (message: string) => void;
+}
+export declare class LightwaveCommandQueue {
+    private queue;
+    private transactions;
+    private busy;
+    private debug;
+    private delay;
+    private timeout;
+    private onExecute;
+    constructor(options: LightwaveCommandQueueOptions);
+    send(message: string | Buffer): Promise<TransactionResponse>;
+    handleResponse(response: TransactionResponse): void;
+    handleRetryableError(transactionId: number): void;
+    destroy(): void;
+    private processQueue;
+    private completeTransaction;
+    private failTransaction;
+}

package/.dist/LightwaveCommandQueue.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveCommandQueue = void 0;
+class LightwaveCommandQueue {
+    queue = [];
+    transactions = new Map();
+    busy = false;
+    debug;
+    delay;
+    timeout;
+    onExecute;
+    constructor(options) {
+        this.debug = options.debug.extend("queue");
+        this.delay = options.delay ?? 800;
+        this.timeout = options.timeout ?? 10000;
+        this.onExecute = options.onExecute;
+    }
+    send(message) {
+        const transactionId = Math.round(Math.random() * Math.pow(10, 8));
+        const messageStr = typeof message === "string" ? message : message.toString("utf-8");
+        const messageWithTransaction = `${transactionId},${messageStr}`;
+        this.debug("[%d] Queueing message: %s", Date.now(), messageWithTransaction);
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const transaction = {
+            id: transactionId,
+            originalMessage: messageStr,
+            message: messageWithTransaction,
+            resolve,
+            reject,
+            delay: this.delay,
+            completed: false,
+        };
+        this.queue.push(transaction);
+        this.transactions.set(transactionId, transaction);
+        this.processQueue();
+        return promise;
+    }
+    handleResponse(response) {
+        const transaction = this.transactions.get(response.id);
+        if (!transaction || transaction.completed) {
+            this.debug("No pending transaction found for id %d or already completed", response.id);
+            return;
+        }
+        this.debug("[%d] Transaction %d completed", Date.now(), response.id);
+        this.completeTransaction(transaction, response);
+    }
+    handleRetryableError(transactionId) {
+        const transaction = this.transactions.get(transactionId);
+        if (!transaction || transaction.completed) {
+            return;
+        }
+        // Clear existing timeout
+        if (transaction.timeoutId) {
+            clearTimeout(transaction.timeoutId);
+            transaction.timeoutId = undefined;
+        }
+        // Exponential backoff, max 10 seconds
+        transaction.delay = Math.min(transaction.delay * 2, 10000);
+        const retryMessage = `${transactionId},${transaction.originalMessage}`;
+        this.debug("Message errored, retrying: %s with delay: %d", retryMessage, transaction.delay);
+        // Set timeout for retry
+        transaction.timeoutId = setTimeout(() => {
+            if (transaction.completed)
+                return;
+            this.debug("Retry timeout expired for transaction %d", transactionId);
+            this.failTransaction(transaction, new Error(`Retry timeout expired ${transactionId}`));
+        }, 5000 + transaction.delay * 2);
+        // Schedule retry
+        transaction.retryTimeoutId = setTimeout(() => {
+            if (transaction.completed)
+                return;
+            this.onExecute(retryMessage);
+        }, Math.round(transaction.delay * 2));
+    }
+    destroy() {
+        for (const transaction of this.transactions.values()) {
+            if (transaction.timeoutId) {
+                clearTimeout(transaction.timeoutId);
+            }
+            if (transaction.retryTimeoutId) {
+                clearTimeout(transaction.retryTimeoutId);
+            }
+            if (!transaction.completed) {
+                transaction.reject(new Error("Queue destroyed"));
+                transaction.completed = true;
+            }
+        }
+        this.transactions.clear();
+        this.queue = [];
+        this.busy = false;
+    }
+    processQueue() {
+        if (this.busy) {
+            this.debug("Queue is busy, waiting to process");
+            return;
+        }
+        const transaction = this.queue.shift();
+        if (!transaction) {
+            return;
+        }
+        this.debug("Processing transaction: %d", transaction.id);
+        this.busy = true;
+        // Set timeout for response
+        transaction.timeoutId = setTimeout(() => {
+            if (transaction.completed)
+                return;
+            this.debug("Transaction %d timed out", transaction.id);
+            this.failTransaction(transaction, new Error(`Execution expired ${transaction.id}`));
+        }, this.timeout);
+        this.onExecute(transaction.message);
+    }
+    completeTransaction(transaction, response) {
+        if (transaction.completed)
+            return;
+        transaction.completed = true;
+        if (transaction.timeoutId) {
+            clearTimeout(transaction.timeoutId);
+        }
+        if (transaction.retryTimeoutId) {
+            clearTimeout(transaction.retryTimeoutId);
+        }
+        this.transactions.delete(transaction.id);
+        transaction.resolve(response);
+        this.debug("Transaction %d completed, scheduling next in %dms", transaction.id, this.delay);
+        setTimeout(() => {
+            this.busy = false;
+            this.processQueue();
+        }, this.delay);
+    }
+    failTransaction(transaction, error) {
+        if (transaction.completed)
+            return;
+        transaction.completed = true;
+        if (transaction.timeoutId) {
+            clearTimeout(transaction.timeoutId);
+        }
+        if (transaction.retryTimeoutId) {
+            clearTimeout(transaction.retryTimeoutId);
+        }
+        this.transactions.delete(transaction.id);
+        transaction.reject(error);
+        this.busy = false;
+        this.processQueue();
+    }
+}
+exports.LightwaveCommandQueue = LightwaveCommandQueue;

package/.dist/LightwaveRFClient.d.ts

@@ -1,6 +1,6 @@
 import { Debugger } from "debug";
 import events from "events";
-import { LightwaveTransaction } from "./LightwaveTransaction";
+import { TransactionResponse } from "./LightwaveCommandQueue";
 declare interface LightwaveRFClientInterface {
     on(event: "ready", listener: (client: LightwaveRFClient) => void): this;
     on(event: "deviceTurnedOn", listener: (room: number, device: number) => void): this;
@@ -15,7 +15,6 @@ export declare class LightwaveRFClient extends events.EventEmitter implements Li
     private commandQueue;
     private messageProcessors;
     private debug;
-    private transactionListeners;
     delay: number;
     serial?: string;
     mac?: string;
@@ -29,8 +28,7 @@ export declare class LightwaveRFClient extends events.EventEmitter implements Li
     connect(): Promise<void>;
     disconnect(): Promise<[void, void]>;
     private checkRegistration;
-    send(message: string | Buffer, callback?: (transaction: LightwaveTransaction | null, error: Error) => void): void;
-    private processSendQueue;
+    send(message: string | Buffer): Promise<TransactionResponse>;
     private exec;
     private processRawMessage;
     private processLightwaveMessage;

package/.dist/LightwaveRFClient.js

@@ -6,19 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LightwaveRFClient = void 0;
 const dgram_1 = __importDefault(require("dgram"));
 const events_1 = __importDefault(require("events"));
+const LightwaveCommandQueue_1 = require("./LightwaveCommandQueue");
 const LightwaveMessageProcessorForJson_1 = require("./LightwaveMessageProcessorForJson");
 const LightwaveMessageProcessorForText_1 = __importDefault(require("./LightwaveMessageProcessorForText"));
-const Queue_1 = require("./Queue");
 const LIGHTWAVE_LINK_SEND_PORT = 9760;
 const LIGHTWAVE_LINK_RECEIVE_PORT = 9761;
 class LightwaveRFClient extends events_1.default.EventEmitter {
     ip;
     senderSocket;
     receiverSocket;
-    commandQueue = new Queue_1.Queue();
+    commandQueue;
     messageProcessors = [];
     debug;
-    transactionListeners = new Map();
     delay = 800;
     serial;
     mac;
@@ -35,6 +34,11 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         this.senderSocket.unref();
         this.receiverSocket = dgram_1.default.createSocket("udp4");
         this.receiverSocket.unref();
+        this.commandQueue = new LightwaveCommandQueue_1.LightwaveCommandQueue({
+            debug: this.debug,
+            delay: this.delay,
+            onExecute: (message) => this.exec(message),
+        });
         this.messageProcessors.push(new LightwaveMessageProcessorForJson_1.LightwaveMessageProcessorForJson(this.debug));
         this.messageProcessors.push(new LightwaveMessageProcessorForText_1.default(this.debug));
     }
@@ -63,74 +67,26 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
     async disconnect() {
         this.receiverSocket.removeAllListeners();
         this.senderSocket.removeAllListeners();
+        this.commandQueue.destroy();
         const { promise: senderPromise, resolve: senderResolve } = Promise.withResolvers();
         const { promise: receiverPromise, resolve: receiverResolve } = Promise.withResolvers();
         this.senderSocket.close(senderResolve);
         this.receiverSocket.close(receiverResolve);
         return Promise.all([senderPromise, receiverPromise]);
     }
-    checkRegistration() {
+    async checkRegistration() {
         this.debug("Checking registration");
-        this.send("@H", (transaction, error) => {
-            if (error) {
-                this.debug("Error: %o", error);
-            }
+        try {
+            const transaction = await this.send("@H");
             this.debug(transaction);
-            this.emit("ready", this);
-        });
-    }
-    send(message, callback) {
-        const transactionId = Math.round(Math.random() * Math.pow(10, 8));
-        const messageWithTransaction = `${transactionId},${message}`;
-        const transactionDebug = this.debug.extend("tx:" + transactionId);
-        this.transactionListeners.set(transactionId, {
-            message: message,
-            debug: transactionDebug,
-            delay: this.delay,
-            callback: callback,
-        });
-        this.debug("[%d] Queueing message: %s", Date.now(), messageWithTransaction);
-        this.commandQueue.add({
-            id: transactionId,
-            message: messageWithTransaction,
-            debug: transactionDebug,
-            callback,
-        });
-        this.processSendQueue();
-    }
-    async processSendQueue() {
-        if (this.commandQueue.busy) {
-            this.debug(`The queue is busy, will wait to process`);
-            return;
         }
-        const command = this.commandQueue.next();
-        if (!command)
-            return;
-        this.debug(`Processing command: %o`, { command });
-        this.commandQueue.busy = true;
-        const transactionListener = this.transactionListeners.get(command.id);
-        const originalCallback = transactionListener.callback;
-        transactionListener.callback = (transaction, error) => {
-            originalCallback?.(transaction, error);
-            this.debug("Transaction %d completed, scheduling next processing in %dms !!!!!!!!!!", transaction.id, this.delay);
-            setTimeout(() => {
-                this.commandQueue.busy = false;
-                this.processSendQueue();
-            }, this.delay);
-        };
-        // If we didn't hear back within the timeout
-        setTimeout(() => {
-            const listener = this.transactionListeners.get(command.id);
-            if (!listener)
-                return;
-            originalCallback?.(null, new Error("Execution expired " + command.id));
-            this.commandQueue.busy = false;
-            this.transactionListeners.delete(command.id);
-            this.processSendQueue();
-        }, 5000);
-        const transactionDebug = this.debug.extend(`transaction:${command?.id}`);
-        transactionDebug("Starting new transaction");
-        this.exec(command.message);
+        catch (error) {
+            this.debug("Error: %o", error);
+        }
+        this.emit("ready", this);
+    }
+    send(message) {
+        return this.commandQueue.send(message);
     }
     exec(message) {
         if (message === undefined)
@@ -174,6 +130,7 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
             this.uptime = lightwaveMessage.uptime;
         }
         if (this.discoverLinkIp) {
+            this.debug(`Updating link ip to ${remoteInfo.address}`);
             this.ip = remoteInfo.address;
         }
         if (lightwaveMessage.fw) {
@@ -196,28 +153,14 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         if (lightwaveMessage.fn === "dim") {
             this.emit("deviceDimmed", lightwaveMessage.room, lightwaveMessage.dev, Math.round((lightwaveMessage.param / 32) * 100));
         }
-        const listener = this.transactionListeners.get(lightwaveMessage.id);
-        if (!listener)
-            return;
+        // Handle retryable errors (ERR,6 = device busy)
         if (lightwaveMessage.error?.match(/^ERR,6,/)) {
-            // Storing delay on a message level provides the ability to implement
-            // exponential backoff, here the maximum is 10 seconds
-            listener.delay = Math.min(listener.delay * 2, 10000);
-            const msg = `${lightwaveMessage.id},${listener.message}`;
-            this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
-            setTimeout(() => {
-                this.exec(msg);
-            }, Math.round(listener.delay * 2));
+            this.commandQueue.handleRetryableError(lightwaveMessage.id);
             return;
         }
-        if (listener) {
-            listener.debug("Found transaction listener");
-            listener.debug("[%d] Transaction completed, removing listener", Date.now());
-            this.transactionListeners.delete(lightwaveMessage.id);
-            listener.callback(lightwaveMessage, null);
-        }
-        else {
-            this.debug("Listener not found for message: %o", lightwaveMessage);
+        // Pass successful response to the queue
+        if (lightwaveMessage.id !== undefined) {
+            this.commandQueue.handleResponse(lightwaveMessage);
         }
     }
 }

package/.dist/index.d.ts

@@ -13,6 +13,7 @@ declare class LightwaveRFConfiguration {
     email?: any;
     pin?: any;
     linkDisplayUpdates?: boolean;
+    discoverLinkIp?: boolean;
 }
 declare interface ILightwaveRF {
     on(event: "deviceTurnedOn", listener: (roomId: number, deviceId: number) => void): this;
@@ -44,7 +45,7 @@ export default class LightwaveRF extends EventEmitter<LightwaveEvents> implement
     lwAccount: LightwaveAccount;
     debug: debug.Debugger;
     private linkDisplayUpdates;
-    constructor({ email, pin, ip, timeout, linkDisplayUpdates, }: LightwaveRFConfiguration);
+    constructor({ email, pin, ip, timeout, linkDisplayUpdates, discoverLinkIp, }: LightwaveRFConfiguration);
     get serial(): string | undefined;
     get mac(): string | undefined;
     get uptime(): number | undefined;

package/.dist/index.js

@@ -18,6 +18,7 @@ class LightwaveRFConfiguration {
     email;
     pin;
     linkDisplayUpdates;
+    discoverLinkIp;
 }
 /** * LightwaveRF API
  *
@@ -39,13 +40,15 @@ class LightwaveRF extends events_1.EventEmitter {
     lwAccount;
     debug;
     linkDisplayUpdates;
-    constructor({ email, pin, ip, timeout, linkDisplayUpdates = true, }) {
+    constructor({ email, pin, ip, timeout, linkDisplayUpdates = true, discoverLinkIp = true, }) {
         super();
         this.setMaxListeners(255);
         this.debug = (0, debug_1.default)("lightwave");
         this.linkDisplayUpdates = linkDisplayUpdates;
         this.debug("Initialising LightwaveRF Client");
-        this.lwClient = new LightwaveRFClient_1.LightwaveRFClient(this.debug, ip);
+        this.lwClient = new LightwaveRFClient_1.LightwaveRFClient(this.debug, ip, {
+            discoverLinkIp,
+        });
         this.lwClient.once("ready", () => {
             this.debug("LightwaveRF ready");
         });
@@ -86,63 +89,41 @@ class LightwaveRF extends events_1.EventEmitter {
         }));
     }
     async turnOn({ roomId, deviceId, roomName, deviceName }) {
-        const { promise, resolve, reject } = Promise.withResolvers();
         const linkDisplayUpdate = this.linkDisplayUpdates
             ? `|${roomName} ${deviceName}|Turn on|`
             : "";
-        this.lwClient.send(`!F1R${roomId}D${deviceId}${linkDisplayUpdate}`, (_, error) => {
-            if (error)
-                return reject(error);
-            resolve();
-        });
-        return promise;
+        await this.lwClient.send(`!F1R${roomId}D${deviceId}${linkDisplayUpdate}`);
     }
     async turnOff({ roomId, deviceId, roomName, deviceName }) {
-        const { promise, resolve, reject } = Promise.withResolvers();
         const linkDisplayUpdate = this.linkDisplayUpdates
             ? `|${roomName} ${deviceName}|Turn off|`
             : "";
-        this.lwClient.send(`!F0R${roomId}D${deviceId}${linkDisplayUpdate}`, (_, error) => {
-            if (error)
-                return reject(error);
-            resolve();
-        });
-        return promise;
+        await this.lwClient.send(`!F0R${roomId}D${deviceId}${linkDisplayUpdate}`);
     }
     async dim({ roomId, deviceId, roomName, deviceName }, percentage) {
-        const { promise, resolve, reject } = Promise.withResolvers();
         const lwDim = Math.round(percentage * 0.32);
         const linkDisplayUpdate = this.linkDisplayUpdates
             ? `|${roomName} ${deviceName}|Dim to ${percentage}%|`
             : "";
-        this.lwClient.send(`!FdP${lwDim}R${roomId}D${deviceId}${linkDisplayUpdate}`, (_, error) => {
-            if (error)
-                return reject(error);
-            resolve();
-        });
-        return promise;
+        await this.lwClient.send(`!FdP${lwDim}R${roomId}D${deviceId}${linkDisplayUpdate}`);
     }
     async connect() {
         return this.lwClient.connect();
     }
     async isRegistered() {
-        return new Promise((resolve) => {
-            const user = process.env.USER;
-            this.lwClient.send(`@H|Check registration|user:${user}|`, (response) => {
-                return resolve(!response?.error);
-            });
-        });
+        const user = process.env.USER;
+        const response = await this.lwClient.send(`@H|Check registration|user:${user}|`);
+        return !response?.error;
     }
     async ensureRegistration() {
+        const user = process.env.USER;
+        const response = await this.lwClient.send(`@H|Check registration|user:${user}|`);
+        if (!response?.error) {
+            return;
+        }
+        this.debug("We are not registered with the hub");
+        await this.lwClient.send("!F*p");
         return new Promise((resolve) => {
-            const user = process.env.USER;
-            this.lwClient.send(`@H|Check registration|user:${user}|`, (response) => {
-                if (!response?.error) {
-                    return resolve();
-                }
-                this.debug("We are not registered with the hub");
-                this.lwClient.send("!F*p");
-            });
             this.lwClient.on("registered", resolve);
         });
     }

package/.dist/index.test.js

@@ -7,6 +7,7 @@ const fetch_vcr_1 = __importDefault(require("fetch-vcr"));
 const vitest_1 = require("vitest");
 const _1 = __importDefault(require("."));
 (0, vitest_1.describe)("LightwaveRF", () => {
+    let lw;
     (0, vitest_1.beforeAll)(() => {
         fetch_vcr_1.default.configure({
             fixturePath: __dirname + "/.fixtures",
@@ -14,8 +15,11 @@ const _1 = __importDefault(require("."));
         });
         global.fetch = fetch_vcr_1.default;
     });
+    (0, vitest_1.afterEach)(async () => {
+        await lw.lwClient.disconnect();
+    });
     (0, vitest_1.it)("should allow device linking", async () => {
-        const lw = new _1.default({
+        lw = new _1.default({
             email: "some@user.com",
             pin: "1234",
         });
@@ -25,7 +29,7 @@ const _1 = __importDefault(require("."));
         await lw.lwClient.disconnect();
     });
     (0, vitest_1.it)("should turn device on", async () => {
-        const lw = new _1.default({
+        lw = new _1.default({
             email: "some@user.com",
             pin: "1234",
             // Disabling link display updates as they cause buffer issues in the link
@@ -36,17 +40,19 @@ const _1 = __importDefault(require("."));
         await lw.connect();
         // await lw.ensureRegistration();
         const devices = await lw.getDevices();
-        const wallLamps = devices?.find((d) => {
-            return d.deviceName === "Table lamp";
+        const roomToInteractWith = "TV Room";
+        const lightToInteractWith = "Lights";
+        const light = devices?.find((d) => {
+            return (d.roomName === roomToInteractWith &&
+                d.deviceName === lightToInteractWith);
         });
-        if (!wallLamps) {
-            throw new Error("Could not find table lamp in the config");
+        if (!light) {
+            throw new Error(`Could not find ${lightToInteractWith} in the config`);
         }
         for (let i = 0; i < 5; i++) {
             console.debug("Turning device on and off", i);
-            await lw.turnOn(wallLamps);
-            await lw.turnOff(wallLamps);
+            await lw.turnOn(light);
+            await lw.turnOff(light);
         }
-        await lw.lwClient.disconnect();
     }, 30000);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evops/lightwaverf",
   "description": "Lightwave RF client library",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "exports": {
     ".": {
       "types": "./.dist/index.d.ts",

package/vitest.config.ts

@@ -6,7 +6,7 @@ export default defineConfig({
     environment: "node",
     printConsoleTrace: true,
     env: {
-      // DEBUG: "lightwave*",
+      DEBUG: "lightwave*",
     },
   },
 });