fix(mqtt-bridge): load devices from config and fix type safety (#352)

Fixes two critical issues in mqtt-bridge:

1. **loadConfig() missing devices field** - Device configurations were silently dropped when loading from config files due to missing schema field and reconstruction logic.

2. **Type safety mismatches** - Zod schemas didn't align with TypeScript interfaces under exactOptionalPropertyTypes, causing compilation failures. Fixed by adding transform functions to conditionally exclude undefined values.

Changes:
- Added devices field to loadConfig() schema and reconstruction
- Made RTU serial parameters required with sensible defaults (parity: none, dataBits: 8, stopBits: 1)
- Made TCP port optional (defaults to 502 in transport layer)
- Added timeout field support for both connection types
- Applied Zod transforms to handle optional fields correctly
- Added 7 comprehensive tests covering all scenarios

All 291 tests passing. TypeScript compilation successful.

Closes #347
Closes #348

Author: groupsky

packages/mqtt-bridge/src/utils/config.test.ts

@@ -117,4 +117,26 @@ describe('loadConfig', () => {
       topicPrefix: 'test',
     })
   })
+
+  it('should load devices from config file', async () => {
+    const configJson = JSON.stringify({
+      mqtt: { url: 'mqtt://localhost:1883' },
+      devices: [
+        {
+          deviceId: 'test-device',
+          driver: '@ya-modbus/driver-ex9em',
+          connection: { type: 'rtu', port: '/dev/ttyUSB0', baudRate: 9600, slaveId: 1 },
+          polling: { interval: 2000 },
+        },
+      ],
+    })
+
+    mockedReadFile.mockResolvedValue(configJson)
+    const config = await loadConfig('/path/to/config.json')
+
+    expect(config.devices).toBeDefined()
+    expect(config.devices).toHaveLength(1)
+    expect(config.devices?.[0].deviceId).toBe('test-device')
+    expect(config.devices?.[0].driver).toBe('@ya-modbus/driver-ex9em')
+  })
 })

packages/mqtt-bridge/src/utils/config.ts

@@ -4,6 +4,8 @@ import { z } from 'zod'
 
 import type { MqttBridgeConfig } from '../types.js'
 
+import { deviceConfigSchema } from './device-validation.js'
+
 const mqttConfigSchema = z.object({
   url: z
     .string()
@@ -29,6 +31,7 @@ const mqttBridgeConfigSchema = z.object({
         'Topic prefix must not contain MQTT special characters (+, #, /, $) or null character',
     })
     .optional(),
+  devices: z.array(deviceConfigSchema).optional(),
 })
 
 export async function loadConfig(configPath: string): Promise<MqttBridgeConfig> {
@@ -56,6 +59,7 @@ export async function loadConfig(configPath: string): Promise<MqttBridgeConfig>
     },
     ...(result.data.stateDir !== undefined && { stateDir: result.data.stateDir }),
     ...(result.data.topicPrefix !== undefined && { topicPrefix: result.data.topicPrefix }),
+    ...(result.data.devices !== undefined && { devices: result.data.devices }),
   }
 
   return config

packages/mqtt-bridge/src/utils/device-validation.test.ts

@@ -380,4 +380,104 @@ describe('validateDeviceConfig', () => {
 
     expect(() => validateDeviceConfig(config)).toThrow('Invalid device configuration')
   })
+
+  describe('RTU connection defaults', () => {
+    it('should apply defaults for omitted RTU serial parameters', () => {
+      const config = {
+        deviceId: 'device1',
+        driver: 'ya-modbus-driver-test',
+        connection: {
+          type: 'rtu',
+          port: '/dev/ttyUSB0',
+          baudRate: 9600,
+          slaveId: 1,
+          // parity, dataBits, stopBits omitted - should get defaults
+        },
+      }
+
+      expect(() => validateDeviceConfig(config)).not.toThrow()
+    })
+
+    it('should accept explicit RTU serial parameters', () => {
+      const config = {
+        deviceId: 'device1',
+        driver: 'ya-modbus-driver-test',
+        connection: {
+          type: 'rtu',
+          port: '/dev/ttyUSB0',
+          baudRate: 9600,
+          slaveId: 1,
+          parity: 'even',
+          dataBits: 7,
+          stopBits: 2,
+        },
+      }
+
+      expect(() => validateDeviceConfig(config)).not.toThrow()
+    })
+
+    it('should accept timeout for RTU connection', () => {
+      const config = {
+        deviceId: 'device1',
+        driver: 'ya-modbus-driver-test',
+        connection: {
+          type: 'rtu',
+          port: '/dev/ttyUSB0',
+          baudRate: 9600,
+          slaveId: 1,
+          timeout: 5000,
+        },
+      }
+
+      expect(() => validateDeviceConfig(config)).not.toThrow()
+    })
+  })
+
+  describe('TCP connection optional port', () => {
+    it('should accept TCP connection without port (defaults to 502)', () => {
+      const config = {
+        deviceId: 'device1',
+        driver: 'ya-modbus-driver-test',
+        connection: {
+          type: 'tcp',
+          host: 'localhost',
+          slaveId: 1,
+          // port omitted - should default to 502
+        },
+      }
+
+      expect(() => validateDeviceConfig(config)).not.toThrow()
+    })
+
+    it('should accept TCP connection with explicit port', () => {
+      const config = {
+        deviceId: 'device1',
+        driver: 'ya-modbus-driver-test',
+        connection: {
+          type: 'tcp',
+          host: 'localhost',
+          port: 8502,
+          slaveId: 1,
+        },
+      }
+
+      expect(() => validateDeviceConfig(config)).not.toThrow()
+    })
+
+    it('should accept timeout for TCP connection', () => {
+      const config = {
+        deviceId: 'device1',
+        driver: 'ya-modbus-driver-test',
+        connection: {
+          type: 'tcp',
+          host: 'localhost',
+          port: 502,
+          slaveId: 1,
+          timeout: 3000,
+        },
+      }
+
+      expect(() => validateDeviceConfig(config)).not.toThrow()
+    })
+  })
 })

packages/mqtt-bridge/src/utils/device-validation.ts

@@ -26,22 +26,38 @@ const driverNameSchema = z
     message: 'Driver name cannot contain path traversal sequences',
   })
 
-const rtuConnectionSchema = z.object({
-  type: z.literal('rtu'),
-  port: z.string().min(1),
-  baudRate: z.number().positive(),
-  slaveId: z.number().int().min(0).max(247),
-  parity: z.enum(['none', 'even', 'odd']).optional(),
-  dataBits: z.union([z.literal(7), z.literal(8)]).optional(),
-  stopBits: z.union([z.literal(1), z.literal(2)]).optional(),
-})
+const rtuConnectionSchema = z
+  .object({
+    type: z.literal('rtu'),
+    port: z.string().min(1),
+    baudRate: z.number().positive(),
+    slaveId: z.number().int().min(0).max(247),
+    parity: z.enum(['none', 'even', 'odd']).default('none'),
+    dataBits: z.union([z.literal(7), z.literal(8)]).default(8),
+    stopBits: z.union([z.literal(1), z.literal(2)]).default(1),
+    timeout: z.number().int().positive().optional(),
+  })
+  .transform((data) => {
+    const { timeout, ...rest } = data
+    return timeout !== undefined ? { ...rest, timeout } : rest
+  })
 
-const tcpConnectionSchema = z.object({
-  type: z.literal('tcp'),
-  host: z.string().min(1),
-  port: z.number().int().positive().max(65535),
-  slaveId: z.number().int().min(0).max(247),
-})
+const tcpConnectionSchema = z
+  .object({
+    type: z.literal('tcp'),
+    host: z.string().min(1),
+    port: z.number().int().positive().max(65535).optional(),
+    slaveId: z.number().int().min(0).max(247),
+    timeout: z.number().int().positive().optional(),
+  })
+  .transform((data) => {
+    const { port, timeout, ...rest } = data
+    return {
+      ...rest,
+      ...(port !== undefined ? { port } : {}),
+      ...(timeout !== undefined ? { timeout } : {}),
+    }
+  })
 
 const pollingConfigSchema = z
   .object({
@@ -59,15 +75,32 @@ const pollingConfigSchema = z
       .optional(),
     retryBackoff: z.number().int().positive().optional(),
   })
+  .transform((data) => {
+    const { maxRetries, retryBackoff, ...rest } = data
+    return {
+      ...rest,
+      ...(maxRetries !== undefined ? { maxRetries } : {}),
+      ...(retryBackoff !== undefined ? { retryBackoff } : {}),
+    }
+  })
   .optional()
 
-export const deviceConfigSchema = z.object({
-  deviceId: deviceIdSchema,
-  driver: driverNameSchema,
-  connection: z.union([rtuConnectionSchema, tcpConnectionSchema]),
-  enabled: z.boolean().optional(),
-  polling: pollingConfigSchema,
-})
+export const deviceConfigSchema = z
+  .object({
+    deviceId: deviceIdSchema,
+    driver: driverNameSchema,
+    connection: z.union([rtuConnectionSchema, tcpConnectionSchema]),
+    enabled: z.boolean().optional(),
+    polling: pollingConfigSchema,
+  })
+  .transform((data) => {
+    const { enabled, polling, ...rest } = data
+    return {
+      ...rest,
+      ...(enabled !== undefined ? { enabled } : {}),
+      ...(polling !== undefined ? { polling } : {}),
+    }
+  })
 
 export function validateDeviceConfig(config: unknown): void {
   const result = deviceConfigSchema.safeParse(config)