isy-nodejs 1.0.1-alpha.9 → 1.0.2-alpha.1

package/dist/esm/ISY.js

@@ -2,42 +2,30 @@ import WebSocket from 'faye-websocket';
 import { writeFile } from 'fs';
 import { Parser } from 'xml2js';
 import { parseBooleans, parseNumbers } from 'xml2js/lib/processors.js';
-import { XmlDocument } from 'xmldoc';
 import axios from 'axios';
 import { EventEmitter } from 'events';
 import { format, Logger, loggers } from 'winston';
-import { Category } from './Definitions/Global/Categories.js';
-import { Family } from './Definitions/Global/Families.js';
 import { DeviceFactory } from './Devices/DeviceFactory.js';
 import { ELKAlarmPanelDevice } from './Devices/Elk/ElkAlarmPanelDevice.js';
-import { ElkAlarmSensorDevice } from './Devices/Elk/ElkAlarmSensorDevice.js';
-import { InsteonBaseDevice } from './Devices/Insteon/InsteonBaseDevice.js';
-import { InsteonOutletDevice } from './Devices/Insteon/InsteonDevice.js';
-import { InsteonDimmableDevice } from './Devices/Insteon/InsteonDimmableDevice.js';
-import { InsteonDimmerOutletDevice } from './Devices/Insteon/InsteonDimmerOutletDevice.js';
-import { InsteonDimmerSwitchDevice } from './Devices/Insteon/InsteonDimmerSwitchDevice.js';
-import { InsteonDoorWindowSensorDevice } from './Devices/Insteon/InsteonDoorWindowSensorDevice.js';
-import { InsteonFanDevice, InsteonFanMotorDevice } from './Devices/Insteon/InsteonFanDevice.js';
-import { InsteonKeypadButtonDevice } from './Devices/Insteon/InsteonKeypadDevice.js';
-import { InsteonKeypadDimmerDevice } from './Devices/Insteon/InsteonKeypadDimmerDevice.js';
-import { InsteonKeypadRelayDevice } from './Devices/Insteon/InsteonKeypadRelayDevice.js';
-import { InsteonLeakSensorDevice } from './Devices/Insteon/InsteonLeakSensorDevice.js';
-import { InsteonLockDevice } from './Devices/Insteon/InsteonLockDevice.js';
-import { InsteonMotionSensorDevice } from './Devices/Insteon/InsteonMotionSensorDevice.js';
-import { InsteonOnOffOutletDevice } from './Devices/Insteon/InsteonOnOffOutletDevice.js';
-import { InsteonRelayDevice } from './Devices/Insteon/InsteonRelayDevice.js';
-import { InsteonSmokeSensorDevice } from './Devices/Insteon/InsteonSmokeSensorDevice.js';
-import { InsteonThermostatDevice } from './Devices/Insteon/InsteonThermostatDevice.js';
 import { ISYDeviceNode } from './Devices/ISYDeviceNode.js';
 import { EventType } from './Events/EventType.js';
-import { NodeType, Props, States, VariableType } from './ISYConstants.js';
-import { ISYNode } from './ISYNode.js';
+import { VariableType } from './ISYConstants.js';
 import { ISYScene } from './ISYScene.js';
 import { ISYVariable } from './ISYVariable.js';
 import * as Utils from './Utils.js';
 import { XMLParser } from 'fast-xml-parser';
+import path from 'path';
 import { NodeFactory } from './Devices/NodeFactory.js';
-export { Category as Categories, ELKAlarmPanelDevice, ElkAlarmSensorDevice, Family, InsteonBaseDevice, InsteonDimmableDevice, InsteonDimmerOutletDevice, InsteonDimmerSwitchDevice, InsteonDoorWindowSensorDevice, InsteonFanDevice, InsteonFanMotorDevice, InsteonKeypadButtonDevice, InsteonKeypadDimmerDevice, InsteonKeypadRelayDevice, InsteonLeakSensorDevice, InsteonLockDevice, InsteonMotionSensorDevice, InsteonOnOffOutletDevice, InsteonOutletDevice, InsteonRelayDevice, InsteonSmokeSensorDevice, InsteonThermostatDevice, ISYDeviceNode as ISYDevice, ISYNode, ISYScene, ISYVariable, NodeType, Props, States, Utils, VariableType };
+import { ISYError } from './ISYError.js';
+import { findPackageJson } from './Utils.js';
+class ISYInitializationError extends ISYError {
+    step;
+    constructor(messageOrError, step) {
+        super(messageOrError);
+        this.name = 'ISYInitializationError';
+        this.step = step;
+    }
+}
 const defaultParserOptions = {
     explicitArray: false,
     mergeAttrs: true,
@@ -103,9 +91,12 @@ export class ISY extends EventEmitter {
     nodesLoaded = false;
     productId = 5226;
     productName = 'eisy';
-    serverVersion;
+    firmwareVersion;
     vendorName = 'Universal Devices, Inc.';
     webSocket;
+    apiVersion;
+    socketPath;
+    axiosOptions;
     // #endregion Properties (30)
     // #region Constructors (1)
     constructor(config, logger = new Logger(), storagePath) {
@@ -121,7 +112,17 @@ export class ISY extends EventEmitter {
         };
         this.protocol = config.protocol;
         this.wsprotocol = config.protocol === 'https' ? 'wss' : 'ws';
-        this.elkEnabled = config.elkEnabled ?? false;
+        this.axiosOptions = {
+            baseURL: `${this.protocol}://${this.host}:${this.port}`,
+            validateStatus: (status) => status >= 200 && status < 300
+        };
+        if (this.socketPath) {
+            this.axiosOptions.socketPath = this.socketPath;
+        }
+        else {
+            this.axiosOptions.auth = { username: this.credentials.username, password: this.credentials.password };
+        }
+        //this.elkEnabled = config.elkEnabled ?? false;
         this.nodesLoaded = false;
         var fopts = format((info) => {
             info.message = JSON.stringify(info.message);
@@ -149,12 +150,7 @@ export class ISY extends EventEmitter {
     // #endregion Public Getters And Setters (2)
     // #region Public Methods (24)
     [Symbol.dispose]() {
-        try {
-            this.webSocket?.close();
-        }
-        catch (e) {
-            this.logger.error(`Error closing websocket: ${e.message}`);
-        }
+        this.close();
     }
     emit(event, node) {
         return super.emit(event, node);
@@ -204,7 +200,7 @@ export class ISY extends EventEmitter {
         return this.variableList;
     }
     async handleInitializeError(step, reason) {
-        this.logger.error(`Error initializing ISY (${step}): ${JSON.stringify(reason)}`);
+        this.logger.error(`Error initializing ISY (${step}): ${Utils.logStringify(reason)}`);
         return Promise.reject(reason);
     }
     handleWebSocketMessage(event) {
@@ -250,7 +246,7 @@ export class ISY extends EventEmitter {
                     }
                     break;
                 case EventType.Heartbeat:
-                    this.logger.debug(`Received ${EventType[Number(stringControl)]} Signal from ISY: ${JSON.stringify(evt)}`);
+                    this.logger.debug(`Received ${EventType[Number(stringControl)]} Signal from ISY: ${Utils.logStringify(evt)}`);
                     break;
                 default:
                     if (evt.node !== '' && evt.node !== undefined && evt.node !== null) {
@@ -265,14 +261,14 @@ export class ISY extends EventEmitter {
                             }
                         }
                         else {
-                            this.logger.warn(`${EventType[stringControl]} Event for Unidentified Device: ${JSON.stringify(evt)}`);
+                            this.logger.debug(`${EventType[stringControl]} Event for Unidentified Device: ${JSON.stringify(evt)}`);
                         }
                     }
                     else {
                         if (stringControl === EventType.NodeChanged) {
-                            this.logger.info(`Received Node Change Event: ${JSON.stringify(evt)}. These are currently unsupported.`);
+                            this.logger.debug(`Received Node Change Event: ${JSON.stringify(evt)}. These are currently unsupported.`);
                         }
-                        this.logger.debug(`${EventType[Number(stringControl)]} Event: ${JSON.stringify(evt)}`);
+                        this.logger.debug(`${EventType[Number(stringControl)]} Event: ${Utils.logStringify(evt)}`);
                     }
                     break;
             }
@@ -280,6 +276,12 @@ export class ISY extends EventEmitter {
     }
     async initialize() {
         const that = this;
+        try {
+            this.apiVersion = (await findPackageJson()).version;
+        }
+        catch (e) {
+            this.logger.error(`Unable to read package.json: ${e.message}`);
+        }
         try {
             await this.loadConfig();
             await this.loadNodes();
@@ -287,74 +289,83 @@ export class ISY extends EventEmitter {
             await this.loadVariables(VariableType.State);
             await this.refreshStatuses();
             await this.#finishInitialize(true);
+            return true;
         }
         catch (e) {
-            this.handleInitializeError('initialize', e);
+            if (e instanceof ISYInitializationError) {
+                this.logger.error(`Error initializing ISY during (${e.step}): ${e.message}`);
+            }
+            else {
+                this.logger.error(`Error initializing ISY: ${e.message}`);
+            }
+            throw e;
         }
         finally {
             if (this.nodesLoaded !== true) {
                 that.#finishInitialize(false);
             }
         }
-        return Promise.resolve(true);
     }
-    initializeWebSocket() {
-        const that = this;
-        const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
-        this.logger.info(`Opening webSocket: ${this.wsprotocol}://${this.address}/rest/subscribe`);
-        if (this.webSocket) {
-            try {
-                this.webSocket.close();
-            }
-            catch (e) {
-                this.logger.warn(`Error closing existing websocket: ${e.message}`);
-            }
-        }
-        this.webSocket = new WebSocket.Client(`${this.wsprotocol}://${this.address}/rest/subscribe`, ['ISYSUB'], {
-            headers: {
-                Origin: 'com.universal-devices.websockets.isy',
-                Authorization: auth
-            },
-            ping: 10
-        });
-        this.lastActivity = new Date();
-        this.webSocket
-            .on('message', (event) => {
-            that.logger.silly(`Received message: ${JSON.stringify(event.data, null, 2)}`);
-            that.handleWebSocketMessage(event);
-        })
-            .on('error', (err, response) => {
-            that.logger.warn(`Websocket subscription error: ${JSON.stringify(err.message)}`);
-            /// throw new Error('Error calling ISY' + err);
-        })
-            .on('fail', (data, response) => {
-            that.logger.warn(`Websocket subscription failure: ${data}`);
-            throw new Error('Failed calling ISY');
-        })
-            .on('abort', () => {
-            that.logger.warn('Websocket subscription aborted.');
-            throw new Error('Call to ISY was aborted');
-        })
-            .on('timeout', (ms) => {
-            that.logger.warn(`Websocket subscription timed out after ${ms} milliseconds.`);
-            throw new Error('Timeout contacting ISY');
-        });
+    async initializeWebSocket() {
+        try {
+            const that = this;
+            const auth = `Basic ${Buffer.from(`${this.credentials.username}:${this.credentials.password}`).toString('base64')}`;
+            this.logger.info(`Opening webSocket: ${this.wsprotocol}://${this.address}/rest/subscribe`);
+            if (this.webSocket) {
+                try {
+                    this.webSocket.close();
+                }
+                catch (e) {
+                    this.logger.warn(`Error closing existing websocket: ${e.message}`);
+                }
+            }
+            this.webSocket = new WebSocket.Client(`${this.wsprotocol}://${this.address}/rest/subscribe`, ['ISYSUB'], {
+                headers: {
+                    Origin: 'com.universal-devices.websockets.isy',
+                    Authorization: auth
+                },
+                ping: 10
+            });
+            this.lastActivity = new Date();
+            this.webSocket
+                .on('message', (event) => {
+                that.logger.silly(`Received message: ${Utils.logStringify(event.data, 1)}`);
+                that.handleWebSocketMessage(event);
+            })
+                .on('error', (err, response) => {
+                that.logger.warn(`Websocket subscription error: ${Utils.logStringify(err, 1)}`);
+            })
+                .on('fail', (data, response) => {
+                that.logger.warn(`Websocket subscription failure: ${data}`);
+                throw new Error('Websocket subscription failure');
+            })
+                .on('abort', () => {
+                that.logger.warn('Websocket subscription aborted.');
+                throw new Error('Websocket subscription aborted.');
+            })
+                .on('timeout', (ms) => {
+                that.logger.warn(`Websocket subscription timed out after ${ms} milliseconds.`);
+                throw new Error('Timeout contacting ISY');
+            });
+        }
+        catch (e) {
+            throw new ISYInitializationError(e, 'websocket');
+        }
     }
     async loadConfig() {
         try {
             this.logger.info('Loading ISY Config');
             const configuration = (await this.sendRequest('config')).configuration;
             if (this.isDebugEnabled) {
-                writeFile(this.storagePath + '/ISYConfigDump.json', JSON.stringify(configuration), this.logger.error);
+                writeFile(path.resolve(this.storagePath, 'ISYConfigDump.json'), JSON.stringify(configuration), this.logger.error);
             }
             const controls = configuration.controls;
             this.model = configuration.deviceSpecs.model;
-            this.serverVersion = configuration.app_version;
+            this.firmwareVersion = configuration.app_full_version;
             this.vendorName = configuration.deviceSpecs.make;
             this.productId = configuration.product.id;
             this.productName = configuration.product.desc;
             this.id = configuration.root.id;
-            // TODO: Check Installed Features
             // this.logger.info(result.configuration);
             if (controls !== undefined) {
                 // this.logger.info(controls.control);
@@ -367,26 +378,32 @@ export class ISY extends EventEmitter {
             return configuration;
         }
         catch (e) {
-            this.handleInitializeError('config', e);
-            throw Error(`Error Loading Config: ${e.message}`);
+            throw new ISYInitializationError(e, 'config');
         }
     }
     async loadNodes() {
         try {
+            this.logger.info('Loading ISY Nodes');
             const result = await this.sendRequest('nodes');
             if (this.isDebugEnabled)
                 writeFile(this.storagePath + '/ISYNodesDump.json', JSON.stringify(result), this.logger.error);
-            await this.#readFolderNodes(result).catch((p) => this.logger.error('Error Loading Folders', p));
-            await this.#readDeviceNodes(result).catch((p) => this.logger.error('Error Loading Devices', p));
-            await this.#readSceneNodes(result).catch((p) => this.logger.error('Error Loading Scenes', p));
+            await this.#readFolderNodes(result);
+            await this.#readDeviceNodes(result);
+            await this.#readSceneNodes(result);
             return result;
         }
         catch (e) {
-            throw new Error(`Error loading nodes: ${e.message}`);
+            if (e instanceof ISYInitializationError) {
+                throw e;
+            }
+            else {
+                throw new ISYInitializationError(e, 'loadNodes');
+            }
         }
     }
     async loadVariables(type) {
         const that = this;
+        this.logger.info(`Loading ISY Variables of type: ${type}`);
         return this.sendRequest(`vars/definitions/${type}`)
             .then((result) => that.#createVariables(type, result))
             .then(() => that.sendRequest(`vars/get/${type}`))
@@ -411,39 +428,11 @@ export class ISY extends EventEmitter {
             if (that.isDebugEnabled) {
                 writeFile(that.storagePath + '/ISYStatusDump.json', JSON.stringify(result), this.logger.error);
             }
-            this.logger.debug(result);
+            //this.logger.debug(result);
             for (const node of result.nodes.node) {
-                this.logger.debug(node);
-                let device = that.getDevice(node.id);
+                let device = that.getNode(node.id);
                 if (device !== null && device !== undefined) {
-                    //   let child = device.children.find((p) => p.address === node.id);
-                    //   if (child) {
-                    //     //Case FanLinc where we treat the light as a child of the fan.
-                    //     device = child;
-                    //   }
                     device.parseResult(node.property);
-                    //   if (Array.isArray(node.property)) {
-                    //     for (let prop of node.property) {
-                    // 		device.applyStatus(prop)
-                    //     //   device.local[prop.id] = device.convertFrom(prop.value, prop.uom);
-                    //     //   device.formatted[prop.id] = prop.formatted;
-                    //     //   device.uom[prop.id] = prop.uom;
-                    //     //   device.logger(
-                    //     //     `Property ${Controls[prop.id].label} (${prop.id}) initialized to: ${device.local[prop.id]} (${
-                    //     //       device.formatted[prop.id]
-                    //     //     })`
-                    //     //   );
-                    //     }
-                    //   } else if (node.property) {
-                    //     device.local[node.property.id] = device.convertFrom(node.property.value, node.property.uom);
-                    //     device.formatted[node.property.id] = node.property.formatted;
-                    //     device.uom[node.property.id] = node.property.uom;
-                    //     device.logger(
-                    //       `Property ${Controls[node.property.id].label} (${node.property.id}) initialized to: ${
-                    //         device.local[node.property.id]
-                    //       } (${device.formatted[node.property.id]})`
-                    //     );
-                    //   }
                 }
             }
         }
@@ -452,8 +441,7 @@ export class ISY extends EventEmitter {
         }
     }
     async sendGetVariable(id, type, handleResult) {
-        const uriToUse = `${this.protocol}://${this.address}/rest/vars/get/${type}/${id}`;
-        this.logger.info(`Sending ISY command...${uriToUse}`);
+        const uriToUse = `vars/get/${type}/${id}`;
         return this.sendRequest(uriToUse).then((p) => handleResult(p.val, p.init));
     }
     async sendISYCommand(path) {
@@ -467,7 +455,12 @@ export class ISY extends EventEmitter {
             if (typeof parameters == 'object') {
                 var q = parameters;
                 for (const paramName of Object.getOwnPropertyNames(q)) {
-                    uriToUse += `/${paramName}/${q[paramName]}`;
+                    if (paramName === 'value') {
+                        uriToUse += `/${q[paramName]}`;
+                        continue;
+                    }
+                    if (typeof q[paramName] === 'string' || typeof q[paramName] === 'number')
+                        uriToUse += `/${paramName}/${q[paramName]}`;
                 }
                 //uriToUse += `/${q[((p : Record<string,number|number>) => `${p[]}/${p.paramValue}` ).join('/')}`;
             }
@@ -481,12 +474,16 @@ export class ISY extends EventEmitter {
     async sendRequest(url, options = { trailingSlash: true }) {
         const requestLogLevel = options.requestLogLevel ?? 'debug';
         const responseLogLevel = options.responseLogLevel ?? 'silly';
-        url = `${this.protocol}://${this.address}/rest/${url}${options.trailingSlash ? '/' : ''}`;
-        this.logger.log(requestLogLevel, `Sending request: ${url}`);
+        const finalUrl = `${this.protocol}://${this.address}/rest/${url}${options.trailingSlash ? '/' : ''}`;
+        this.logger.log(requestLogLevel, `Sending request: ${finalUrl}`);
+        const reqOps = { ...this.axiosOptions, ...options, url: path.join('/rest', url) };
+        /*{
+                auth: { username: this.credentials.username, password: this.credentials.password },
+                baseURL: `${this.protocol}://${this.address}`,
+
+            }*/
         try {
-            const response = await axios.get(url, {
-                auth: { username: this.credentials.username, password: this.credentials.password }
-            });
+            const response = await axios.get(finalUrl, reqOps);
             if (response.data) {
                 if (response.headers['content-type'].toString().includes('xml')) {
                     let curParser = parser;
@@ -498,21 +495,26 @@ export class ISY extends EventEmitter {
                     return s;
                 }
                 else if (response.headers['content-type'].toString().includes('json')) {
-                    this.logger.log(responseLogLevel ?? 'debug', `Response: ${JSON.stringify(response.data)}`);
+                    this.logger.log(responseLogLevel, `Response: ${JSON.stringify(response.data)}`);
                     return JSON.parse(response.data);
                 }
                 else {
-                    this.logger.log(responseLogLevel ?? 'debug', `Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`);
+                    this.logger.log(responseLogLevel, `Response Header: ${JSON.stringify(response.headers)} Response: ${JSON.stringify(response.data)}`);
                     return response.data;
                 }
             }
         }
         catch (error) {
-            if (options.errorLogLevel) {
-                this.logger.log(options.errorLogLevel, `Error sending request to ISY: ${error?.message}`);
+            if (options.throwOnError) {
+                throw error;
             }
             else {
-                this.logger.error(`Error sending request to ISY: ${error?.message}`);
+                if (options.errorLogLevel) {
+                    this.logger.log(options.errorLogLevel, `Error sending request to ISY: ${error?.message}`);
+                }
+                else {
+                    this.logger.error(`Error sending request to ISY: ${error?.message}`);
+                }
             }
         }
     }
@@ -525,8 +527,12 @@ export class ISY extends EventEmitter {
         this.logger.info(`Variable: ${variable.id} (${variable.type}) changed`);
     }
     close() {
-        if (this.webSocket)
-            this.webSocket.close();
+        try {
+            this.webSocket?.close();
+        }
+        catch (e) {
+            this.logger.error(`Error closing websocket: ${e.message}`);
+        }
     }
     // #endregion Public Methods (24)
     // #region Private Methods (11)
@@ -592,103 +598,134 @@ export class ISY extends EventEmitter {
             }
         });
     }
-    #loadElkNodes(result) {
+    /* #loadElkNodes(result: any) {
         const document = new XmlDocument(result);
         const nodes = document.childNamed('areas').childNamed('area').childrenNamed('zone');
         for (let index = 0; index < nodes.length; index++) {
             const id = nodes[index].attr.id;
             const name = nodes[index].attr.name;
             const alarmDef = nodes[index].attr.alarmDef;
-            const newDevice = new ElkAlarmSensorDevice(this, name, 1, id /*TODO: Handle CO Sensor vs. Door/Window Sensor */);
+            const newDevice = new ElkAlarmSensorDevice(this, name, 1, id TODO: Handle CO Sensor vs. Door/Window Sensor );
             this.zoneMap[newDevice.zone] = newDevice;
         }
-    }
+    } */
     async #readDeviceNodes(obj) {
-        this.logger.info('Loading Device Nodes');
-        for (const nodeInfo of obj.nodes.node) {
-            try {
-                this.logger.debug(`Loading Device Node: ${JSON.stringify(nodeInfo)}`);
-                if (!this.deviceMap.has(nodeInfo.pnode)) {
-                    const address = nodeInfo.address;
-                    this.deviceMap[nodeInfo.pnode] = {
-                        address
-                    };
-                }
-                else {
-                    this.deviceMap[nodeInfo.pnode].push(nodeInfo.address);
-                }
-                let newDevice = null;
-                // let deviceTypeInfo = this.isyTypeToTypeName(device.type, device.address);
-                // this.logger.info(JSON.stringify(deviceTypeInfo));
-                const enabled = nodeInfo.enabled ?? true;
-                const d = await NodeFactory.get(nodeInfo);
-                const m = DeviceFactory.getDeviceDetails(nodeInfo);
-                if (d) {
-                    newDevice = new d(this, nodeInfo);
-                }
-                if (m) {
-                    newDevice = newDevice ?? new m.class(this, nodeInfo);
-                    newDevice.productName = m.name;
-                    newDevice.model = `(${m.modelNumber}) ${m.name} v.${m.version}`;
-                    newDevice.modelNumber = m.modelNumber;
-                    newDevice.version = m.version;
-                }
-                if (enabled) {
-                    if (newDevice === null) {
-                        this.logger.warn(`Device type resolution failed for ${nodeInfo.name} with type: ${nodeInfo.type} and nodedef: ${nodeInfo.nodeDefId}`);
-                        newDevice = new ISYDeviceNode(this, nodeInfo);
+        try {
+            this.logger.info('Reading Device Nodes');
+            for (const nodeInfo of obj.nodes.node) {
+                try {
+                    this.logger.debug(`Loading Device Node: ${JSON.stringify(nodeInfo)}`);
+                    if (!this.deviceMap.has(nodeInfo.pnode)) {
+                        const address = nodeInfo.address;
+                        this.deviceMap[nodeInfo.pnode] = {
+                            address
+                        };
+                    }
+                    else {
+                        this.deviceMap[nodeInfo.pnode].push(nodeInfo.address);
                     }
-                    else if (newDevice !== null) {
-                        if (m.unsupported) {
-                            this.logger.warn('Device not currently supported: ' + JSON.stringify(nodeInfo) + ' /n It has been mapped to: ' + d.name);
+                    let newDevice = null;
+                    // let deviceTypeInfo = this.isyTypeToTypeName(device.type, device.address);
+                    // this.logger.info(JSON.stringify(deviceTypeInfo));
+                    const enabled = nodeInfo.enabled ?? true;
+                    const d = await NodeFactory.get(nodeInfo);
+                    const m = DeviceFactory.getDeviceDetails(nodeInfo);
+                    const cls = m?.class ?? d;
+                    nodeInfo.property = Array.isArray(nodeInfo.property) ? nodeInfo.property : [nodeInfo.property];
+                    nodeInfo.state = nodeInfo.property.reduce((acc, p) => {
+                        if (p && p?.id) {
+                            p.name = p.name == '' ? undefined : p.name;
+                            acc[p.id] = p;
                         }
+                        return acc;
+                    }, {});
+                    if (cls) {
                         try {
-                            await newDevice.refreshNotes();
+                            newDevice = new cls(this, nodeInfo);
                         }
                         catch (e) {
-                            this.logger.debug('No notes found.');
+                            this.logger.error(`Error creating device ${nodeInfo.name} with type ${nodeInfo.type} and nodedef ${nodeInfo.nodeDefId}: ${e.message}`);
+                            continue;
                         }
-                        // if (!newDevice.hidden) {
-                        // }
-                        // this.deviceList.push(newDevice);
+                        //newDevice = new cls(this, nodeInfo) as ISYDeviceNode<any, any, any, any>;
+                    }
+                    if (m && newDevice) {
+                        newDevice.productName = m.name;
+                        newDevice.model = `(${m.modelNumber}) ${m.name} v.${m.version}`;
+                        newDevice.modelNumber = m.modelNumber;
+                        newDevice.version = m.version;
+                    }
+                    if (enabled) {
+                        if (newDevice === null) {
+                            this.logger.warn(`Device type resolution failed for ${nodeInfo.name} with type: ${nodeInfo.type} and nodedef: ${nodeInfo.nodeDefId}`);
+                            newDevice = new ISYDeviceNode(this, nodeInfo);
+                        }
+                        else if (newDevice !== null) {
+                            if (m.unsupported) {
+                                this.logger.warn('Device not currently supported: ' + JSON.stringify(nodeInfo) + ' /n It has been mapped to: ' + d.name);
+                            }
+                            try {
+                                await newDevice.refreshNotes();
+                            }
+                            catch (e) {
+                                this.logger.debug('No notes found.');
+                            }
+                            // if (!newDevice.hidden) {
+                            // }
+                            // this.deviceList.push(newDevice);
+                        }
+                        else {
+                        }
+                        this.nodeMap.set(newDevice.address, newDevice);
                     }
                     else {
+                        this.logger.info(`Ignoring disabled device: ${nodeInfo.name}`);
                     }
-                    this.nodeMap.set(newDevice.address, newDevice);
                 }
-                else {
-                    this.logger.info(`Ignoring disabled device: ${nodeInfo.name}`);
+                catch (e) {
+                    this.logger.error(`Error loading device node: ${e.message}`);
                 }
             }
-            catch (e) {
-                this.logger.error(`Error loading device node: ${e.message}`);
-            }
+            this.logger.info(`${this.nodeMap.size} devices added.`);
+        }
+        catch (e) {
+            throw new ISYInitializationError(e, 'readDevices');
         }
-        this.logger.info(`${this.nodeMap.size} devices added.`);
     }
     async #readFolderNodes(result) {
-        this.logger.info('Loading Folder Nodes');
-        if (result?.nodes?.folder) {
-            for (const folder of result.nodes.folder) {
-                this.logger.info(`Loading Folder Node: ${JSON.stringify(folder)}`);
-                this.folderMap.set(folder.address, folder.name);
+        try {
+            this.logger.info('Reading Folder Nodes');
+            if (result?.nodes?.folder) {
+                for (const folder of result.nodes.folder) {
+                    this.logger.debug(`Loading Folder Node: ${JSON.stringify(folder)}`);
+                    this.folderMap.set(folder.address, folder.name);
+                }
             }
         }
+        catch (e) {
+            throw new ISYInitializationError(e, 'readFolders');
+        }
     }
     async #readSceneNodes(result) {
-        this.logger.info('Loading Scene Nodes');
-        for (const scene of result.nodes?.group) {
-            if (scene.name === 'ISY' || scene.name === 'IoX' || scene.name === 'Auto DR') {
-                continue;
-            } // Skip ISY & Auto DR Scenes
-            const newScene = new ISYScene(this, scene);
-            try {
-                await newScene.refreshNotes();
-            }
-            catch (e) {
-                this.logger.debug('No notes found.');
-            }
-            this.sceneList.set(newScene.address, newScene);
+        try {
+            this.logger.info('Loading Scene Nodes');
+            for (const scene of result.nodes?.group) {
+                if (scene.name === 'ISY' || scene.name === 'IoX' || scene.name === 'Auto DR') {
+                    continue;
+                } // Skip ISY & Auto DR Scenes
+                const newScene = new ISYScene(this, scene);
+                try {
+                    await newScene.refreshNotes();
+                }
+                catch (e) {
+                    this.logger.debug('No notes found.');
+                }
+                this.sceneList.set(newScene.address, newScene);
+            }
+            this.logger.info(`${this.sceneList.size} scenes added.`);
+        }
+        catch (e) {
+            throw new ISYInitializationError(e, 'readScenes');
         }
     }
     #setVariableValues(result) {