Allow enabling/disabling device sources and known devices

src/app.ts

@@ -14,7 +14,7 @@ import { ClientToServerEvents, ServerToClientEvents, WebsocketServer } from './s
 import { SerializedDevice } from './device/serializedTypes.js';
 import { SerializedSettings } from './settings/serializedTypes.js';
 import AutomationServiceProvider from './serviceProvider/automationServiceProvider.js';
-import Device from './device/device.js';
+import { AnyDevice } from './device/device.js';
 import WebSocketEvent from './device/webSocketEvent.js';
 import AutomationEventType from './automation/automationEventType.js';
 import LoggerServiceProvider from './serviceProvider/loggerServiceProvider.js';
@@ -104,49 +104,50 @@ const configureWebsocket = (io: WebsocketServer, container: Container<ServiceMap
         socket.on(WebSocketEvent.deviceUpdateReceived, (data) => deviceUpdateHandler.handle(data));
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceConnected, (device: Device) => {
+    deviceManager.on(DeviceManagerEvent.deviceConnected, (device: AnyDevice) => {
         io.emit(WebSocketEvent.deviceConnected, serializer.transform<SerializedDevice>(device, deviceDiscriminator));
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceConnected, device, args: [] });
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceDisconnected, (device: Device) => {
+    deviceManager.on(DeviceManagerEvent.deviceDisconnected, (device: AnyDevice) => {
         io.emit(WebSocketEvent.deviceDisconnected, serializer.transform<SerializedDevice>(device, deviceDiscriminator));
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceDisconnected, device, args: [] });
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceRefreshed, (device: Device) => {
+    deviceManager.on(DeviceManagerEvent.deviceRefreshed, (device: AnyDevice) => {
         io.emit(WebSocketEvent.deviceRefreshed, serializer.transform<SerializedDevice>(device, deviceDiscriminator));
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceRefreshed, device, args: [] });
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceNotification, (device: Device, notification) => {
+    deviceManager.on(DeviceManagerEvent.deviceNotification, (device: AnyDevice, notification) => {
         io.emit(WebSocketEvent.deviceNotification, serializer.transform<SerializedDevice>(device, deviceDiscriminator), notification);
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceNotification, device, args: [notification] });
     });
 
     settingsManager.on(SettingsEventType.changed, (settings: Settings) => {
         io.emit(SettingsEventType.changed, serializer.transform<SerializedSettings>(settings));
+
+        deviceManager
+            .onSettingsChanged()
+            .catch(e => logError(logger, 'Failed to apply device enabled/disabled changes', e));
+
+        container.get('device.provider.loader')
+            .loadFromSettings(settings)
+            .catch(e => logError(logger, 'Failed to reload device sources after settings change', e));
     });
 
     // Automation events
     scriptRuntime.on(AutomationEventType.consoleLog, (data: string) => io.emit(AutomationEventType.consoleLog, data));
 };
 
 const loadDeviceProviders = (container: Container<ServiceMap>): void => {
-    const serialPortObserver = container.get('device.observer.serial');
-    const bleObserver = container.get('device.observer.ble');
     const logger = container.get('logger.default');
     const settings = container.get('settings');
     const deviceProviderManager = container.get('device.provider.loader');
 
-    deviceProviderManager.loadFromSettings(settings);
-
     deviceProviderManager
-        .startProviders()
+        .loadFromSettings(settings)
         .catch(e => logError(logger, `Loading device providers failed`, e));
-
-    serialPortObserver.start().catch(e => logError(logger, `Initializing serial port observer failed`, e));
-    bleObserver.init().catch(e => logError(logger, `Initializing BLE observer failed`, e));
 };
 
 const buildCorsOptions = (allowedOrigins: string[]): CorsOptions => ({
@@ -259,8 +260,6 @@ export const createApp = (container: Container<ServiceMap>, options: AppOptions)
             logger.info('Shutting down...');
 
             await container.get('automation.scriptRuntime').stop();
-            await container.get('device.observer.serial').stop();
-            await container.get('device.observer.ble').stop();
             await container.get('device.provider.loader').stopProviders();
             container.get('health.metricsCollector').stop();
 

src/automation/scriptRuntime.ts

@@ -1,6 +1,6 @@
 import ivm from 'isolated-vm';
 import { transform } from 'sucrase';
-import Device, { DeviceNotification } from '../device/device.js';
+import { AnyDevice, DeviceNotification } from '../device/device.js';
 import DeviceRepositoryInterface from '../repository/deviceRepositoryInterface.js';
 import fs, { WriteStream } from 'fs';
 import readLastLines from 'read-last-lines/dist/index.js';
@@ -11,8 +11,8 @@ import { AttributeValue } from '../device/attribute/deviceAttribute.js';
 import Logger from '../logging/Logger.js';
 
 export type SupportedDeviceEvent =
-    | { type: DeviceManagerEvent.deviceConnected | DeviceManagerEvent.deviceDisconnected | DeviceManagerEvent.deviceRefreshed; device: Device; args: [] }
-    | { type: DeviceManagerEvent.deviceNotification; device: Device; args: [notification: DeviceNotification] };
+    | { type: DeviceManagerEvent.deviceConnected | DeviceManagerEvent.deviceDisconnected | DeviceManagerEvent.deviceRefreshed; device: AnyDevice; args: [] }
+    | { type: DeviceManagerEvent.deviceNotification; device: AnyDevice; args: [notification: DeviceNotification] };
 
 type ScriptRuntimeEvents = {
     [AutomationEventType.consoleLog]: (data: string) => void,

src/controller/settings/putSettingsController.ts

@@ -2,7 +2,7 @@ import { Request, Response } from 'express';
 import ControllerInterface from '../controllerInterface.js';
 import SettingsManager from '../../settings/settingsManager.js';
 import Settings, { SettingsSchema } from '../../settings/settings.js';
-import JsonSchemaValidator from '../../schemaValidation/JsonSchemaValidator.js';
+import SchemaValidationError from '../../schemaValidation/schemaValidationError.js';
 import PlainToClassSerializer from '../../serialization/plainToClassSerializer.js';
 import ClassToPlainSerializer from '../../serialization/classToPlainSerializer.js';
 import { JsonObject } from '../../types.js';
@@ -17,35 +17,34 @@ export default class PutSettingsController implements ControllerInterface
 
     private classToPlainSerializer: ClassToPlainSerializer;
 
-    private settingsSchemaValidator: JsonSchemaValidator<typeof SettingsSchema>;
-
     public constructor(
         settingsManager: SettingsManager,
         classToPlainSerializer: ClassToPlainSerializer,
-        plainToClassSerializer: PlainToClassSerializer,
-        settingsSchemaValidator: JsonSchemaValidator<typeof SettingsSchema>
+        plainToClassSerializer: PlainToClassSerializer
     ) {
         this.settingsManager = settingsManager;
-        this.settingsSchemaValidator = settingsSchemaValidator;
         this.plainToClassSerializer = plainToClassSerializer;
         this.classToPlainSerializer = classToPlainSerializer;
     }
 
     public execute(req: PutSettingsRequest, res: Response): void
     {
-        const valid = this.settingsSchemaValidator.validate(req.body);
+        let settings: Settings;
+
+        try {
+            settings = this.plainToClassSerializer.transform(Settings, req.body, SettingsSchema);
+        } catch (e: unknown) {
+            if (!(e instanceof SchemaValidationError)) {
+                throw e;
+            }
 
-        if (!valid) {
-            const validationErrors = this.settingsSchemaValidator.getValidationErrors();
             res.status(400).json({
                 message: `Settings are not in a valid format`,
-                errors: [...validationErrors]
+                errors: e.validationErrors
             });
             return;
         }
 
-        const settings = this.plainToClassSerializer.transform(Settings, req.body);
-
         this.settingsManager.replace(settings);
 
         res.send(JSON.stringify(this.classToPlainSerializer.transform(

src/device/bleDevice.ts

@@ -2,18 +2,17 @@ import { Peripheral } from '@stoprocent/noble';
 import BaseError from 'modern-errors';
 import Device, { DeviceAttributes, DeviceNotifications, NoDeviceNotifications } from './device.js';
 import { AnyDeviceConfig, NoDeviceConfig } from './deviceConfig.js';
+import { AttributeValue } from './attribute/deviceAttribute.js';
 import { Expose } from 'class-transformer';
 import { EventEmitter } from 'events';
 import { DeviceId } from './deviceId.js';
 import { logError } from '../util/error.js';
 import Logger from '../logging/Logger.js';
 import { asyncHandler, promiseWithTimeout } from '../util/async.js';
 
-export type InferBleDeviceAttributes<D extends BleDevice<any, any, any>> =
-    D extends BleDevice<infer TAttrs, any, any> ? TAttrs : DeviceAttributes;
-
-export type InferBleDeviceConfig<D extends BleDevice<any, any, any>> =
-    D extends BleDevice<any, any, infer TCfg> ? TCfg : AnyDeviceConfig;
+export type AnyBleDevice = Omit<BleDevice, 'setAttribute'> & {
+    setAttribute(attributeName: string, value: AttributeValue): Promise<AttributeValue>;
+};
 
 export default abstract class BleDevice<
     TAttributes extends DeviceAttributes = DeviceAttributes,
@@ -78,6 +77,10 @@ export default abstract class BleDevice<
         this.peripheral.on('disconnect', this.reconnectHandler);
     }
 
+    public getPeripheral(): Peripheral {
+        return this.peripheral;
+    }
+
     private async requestRssiUpdate(): Promise<void> {
         if (this.closing || this.peripheral.state === 'disconnected') {
             return;

src/device/device.ts

@@ -1,21 +1,12 @@
 import { Exclude, Expose } from 'class-transformer';
 import DeviceState from './deviceState.js';
-import DeviceAttribute from './attribute/deviceAttribute.js';
+import DeviceAttribute, { AttributeValue } from './attribute/deviceAttribute.js';
 import { AnyDeviceConfig, NoDeviceConfig } from './deviceConfig.js';
 import { EventEmitter } from 'events';
 import type { DeviceId } from './deviceId.js';
 import type { JsonObject } from '../types.js';
 import { DropFirst } from '../types.js';
 
-export type InferDeviceAttributes<D extends Device<DeviceAttributes, DeviceNotifications, AnyDeviceConfig>> =
-    D extends Device<infer TAttrs, any, any> ? TAttrs : DeviceAttributes;
-
-export type InferDeviceNotifications<D extends Device<DeviceAttributes, DeviceNotifications, AnyDeviceConfig>> =
-    D extends Device<any, infer TNotifs, any> ? TNotifs : AnyDeviceNotifications;
-
-export type InferDeviceConfig<D extends Device<DeviceAttributes, DeviceNotifications, AnyDeviceConfig>> =
-    D extends Device<any, any, infer TCfg> ? TCfg : AnyDeviceConfig;
-
 // An attribute value can be DeviceAttribute or undefined because we want to allow Partial<>
 export type DeviceAttributes = Record<string, DeviceAttribute | undefined>;
 
@@ -58,6 +49,10 @@ export type DeviceEventMap<
     [DeviceEvent.deviceNotification]: [device: TDevice, notification: DeviceNotification<TNotifications>];
 }
 
+export type AnyDevice = Omit<Device, 'setAttribute'> & {
+    setAttribute(attributeName: string, value: AttributeValue): Promise<AttributeValue>;
+};
+
 @Exclude()
 export default abstract class Device<
     TAttributes extends DeviceAttributes = DeviceAttributes,