@kusinta/iot-schema 0.1.0-beta.2

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@kusinta/iot-schema",
+  "version": "0.1.0-beta.2",
+  "type": "module",
+  "files": ["src"],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    "./common":                 "./src/kusinta/iot/common/v1/types_pb.js",
+    "./identity":               "./src/kusinta/iot/identity/v1/identity_pb.js",
+    "./device":                 "./src/kusinta/iot/device/v1/device_pb.js",
+    "./device/descriptor":      "./src/kusinta/iot/device/v1/descriptor_pb.js",
+    "./device/properties":      "./src/kusinta/iot/device/v1/properties_pb.js",
+    "./device/property-update": "./src/kusinta/iot/device/v1/property_update_pb.js",
+    "./space":                  "./src/kusinta/iot/space/v1/space_pb.js",
+    "./access":                 "./src/kusinta/iot/access/v1/acl_pb.js",
+    "./access/roles":           "./src/kusinta/iot/access/v1/roles_pb.js",
+    "./connector":              "./src/kusinta/iot/connector/v1/connector_pb.js",
+    "./connector/service":      "./src/kusinta/iot/connector/v1/connector_service_pb.js",
+    "./webrtc":                 "./src/kusinta/iot/webrtc/v1/envelope_pb.js"
+  },
+  "dependencies": {
+    "@bufbuild/protobuf": "^2.12.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "vitest": "^3.0.0"
+  }
+}

package/src/__tests__/access.test.js

@@ -0,0 +1,134 @@
+// @ts-check
+import { describe, it, expect } from 'vitest'
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf'
+import { Role, PermissionAction } from '../kusinta/iot/access/v1/roles_pb.js'
+import {
+  PropertyConstraintSchema,
+  DeviceAclSchema,
+  EffectivePermissionsSchema,
+} from '../kusinta/iot/access/v1/acl_pb.js'
+
+describe('Role and PermissionAction enums', () => {
+  it('Role.RESIDENT is defined', () => {
+    expect(Role.RESIDENT).toBeDefined()
+  })
+
+  it('Role.PROPERTY_OWNER is defined', () => {
+    expect(Role.PROPERTY_OWNER).toBeDefined()
+  })
+
+  it('PermissionAction.WRITE is defined', () => {
+    expect(PermissionAction.WRITE).toBeDefined()
+  })
+})
+
+describe('PropertyConstraint — property-owner setpoint limits', () => {
+  it('round-trips int_max constraint for MaxHeatSetpointLimit', () => {
+    const c = create(PropertyConstraintSchema, {
+      attributeName: 'MaxHeatSetpointLimit',
+      constraint: { case: 'intMax', value: 2200 },
+      clusterIdHex: '0201',
+    })
+    const decoded = fromBinary(PropertyConstraintSchema, toBinary(PropertyConstraintSchema, c))
+    expect(decoded.attributeName).toBe('MaxHeatSetpointLimit')
+    expect(decoded.constraint?.case).toBe('intMax')
+    if (decoded.constraint?.case === 'intMax') {
+      expect(decoded.constraint.value).toBe(2200)
+    }
+  })
+
+  it('round-trips int_min constraint for MinHeatSetpointLimit', () => {
+    const c = create(PropertyConstraintSchema, {
+      attributeName: 'MinHeatSetpointLimit',
+      constraint: { case: 'intMin', value: 1600 },
+      clusterIdHex: '0201',
+    })
+    const decoded = fromBinary(PropertyConstraintSchema, toBinary(PropertyConstraintSchema, c))
+    expect(decoded.constraint?.case).toBe('intMin')
+    if (decoded.constraint?.case === 'intMin') {
+      expect(decoded.constraint.value).toBe(1600)
+    }
+  })
+
+  it('round-trips uint_max constraint', () => {
+    const c = create(PropertyConstraintSchema, {
+      attributeName: 'CurrentLevel',
+      constraint: { case: 'uintMax', value: 200 },
+      clusterIdHex: '0008',
+    })
+    const decoded = fromBinary(PropertyConstraintSchema, toBinary(PropertyConstraintSchema, c))
+    expect(decoded.constraint?.case).toBe('uintMax')
+  })
+})
+
+describe('DeviceAcl', () => {
+  it('round-trips resident acl with allowed actions and constraints', () => {
+    const acl = create(DeviceAclSchema, {
+      deviceId: { value: 'therm-1' },
+      userId: { value: 'user-resident-1' },
+      role: Role.RESIDENT,
+      allowedActions: [PermissionAction.READ, PermissionAction.WRITE],
+      allowedAttributes: ['OccupiedHeatingSetpoint', 'LocalTemperature'],
+      propertyConstraints: [
+        {
+          attributeName: 'OccupiedHeatingSetpoint',
+          constraint: { case: 'intMax', value: 2200 },
+          clusterIdHex: '0201',
+        },
+        {
+          attributeName: 'OccupiedHeatingSetpoint',
+          constraint: { case: 'intMin', value: 1600 },
+          clusterIdHex: '0201',
+        },
+      ],
+    })
+    const decoded = fromBinary(DeviceAclSchema, toBinary(DeviceAclSchema, acl))
+    expect(decoded.deviceId?.value).toBe('therm-1')
+    expect(decoded.userId?.value).toBe('user-resident-1')
+    expect(decoded.role).toBe(Role.RESIDENT)
+    expect(decoded.allowedActions).toEqual([PermissionAction.READ, PermissionAction.WRITE])
+    expect(decoded.allowedAttributes).toEqual(['OccupiedHeatingSetpoint', 'LocalTemperature'])
+    expect(decoded.propertyConstraints).toHaveLength(2)
+    expect(decoded.propertyConstraints[0].constraint?.case).toBe('intMax')
+  })
+
+  it('round-trips property-owner acl', () => {
+    const acl = create(DeviceAclSchema, {
+      deviceId: { value: 'therm-1' },
+      userId: { value: 'user-owner-1' },
+      role: Role.PROPERTY_OWNER,
+      allowedActions: [PermissionAction.READ, PermissionAction.WRITE, PermissionAction.OBSERVE],
+    })
+    const decoded = fromBinary(DeviceAclSchema, toBinary(DeviceAclSchema, acl))
+    expect(decoded.role).toBe(Role.PROPERTY_OWNER)
+  })
+})
+
+describe('EffectivePermissions', () => {
+  it('round-trips with multiple device acls', () => {
+    const perms = create(EffectivePermissionsSchema, {
+      userId: { value: 'user-1' },
+      gatewayId: { value: 'gw-1' },
+      deviceAcls: [
+        {
+          deviceId: { value: 'therm-1' },
+          userId: { value: 'user-1' },
+          role: Role.RESIDENT,
+          allowedActions: [PermissionAction.READ, PermissionAction.WRITE],
+        },
+        {
+          deviceId: { value: 'light-1' },
+          userId: { value: 'user-1' },
+          role: Role.RESIDENT,
+          allowedActions: [PermissionAction.READ, PermissionAction.WRITE],
+        },
+      ],
+    })
+    const decoded = fromBinary(EffectivePermissionsSchema, toBinary(EffectivePermissionsSchema, perms))
+    expect(decoded.userId?.value).toBe('user-1')
+    expect(decoded.gatewayId?.value).toBe('gw-1')
+    expect(decoded.deviceAcls).toHaveLength(2)
+    expect(decoded.deviceAcls[0].deviceId?.value).toBe('therm-1')
+    expect(decoded.deviceAcls[1].deviceId?.value).toBe('light-1')
+  })
+})

package/src/__tests__/common.test.js

@@ -0,0 +1,29 @@
+// @ts-check
+import { describe, it, expect } from 'vitest'
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf'
+import { ErrorDetailSchema } from '../kusinta/iot/common/v1/types_pb.js'
+
+describe('ErrorDetail', () => {
+  it('round-trips code and message', () => {
+    const original = create(ErrorDetailSchema, { code: 'NOT_FOUND', message: 'device not found', metadata: {} })
+    const decoded = fromBinary(ErrorDetailSchema, toBinary(ErrorDetailSchema, original))
+    expect(decoded.code).toBe('NOT_FOUND')
+    expect(decoded.message).toBe('device not found')
+  })
+
+  it('round-trips metadata map entries', () => {
+    const original = create(ErrorDetailSchema, {
+      code: 'PERMISSION_DENIED',
+      message: 'write not allowed',
+      metadata: { deviceId: 'abc-123', attribute: 'OccupiedHeatingSetpoint' },
+    })
+    const decoded = fromBinary(ErrorDetailSchema, toBinary(ErrorDetailSchema, original))
+    expect(decoded.metadata['deviceId']).toBe('abc-123')
+    expect(decoded.metadata['attribute']).toBe('OccupiedHeatingSetpoint')
+  })
+
+  it('produces an empty byte array for a default instance', () => {
+    const bytes = toBinary(ErrorDetailSchema, create(ErrorDetailSchema))
+    expect(bytes.length).toBe(0)
+  })
+})

package/src/__tests__/connector.test.js

@@ -0,0 +1,144 @@
+// @ts-check
+import { describe, it, expect } from 'vitest'
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf'
+import {
+  ConnectRequestSchema,
+  ConnectResponseSchema,
+  ConnectorHandshakeSchema,
+  HandshakeAckSchema,
+  DeviceAnnouncementSchema,
+  DeviceRemovalSchema,
+} from '../kusinta/iot/connector/v1/connector_pb.js'
+import { ConnectorTransport } from '../kusinta/iot/common/v1/types_pb.js'
+
+describe('ConnectorHandshake', () => {
+  it('round-trips with known_devices', () => {
+    const h = create(ConnectorHandshakeSchema, {
+      info: {
+        connectorId: { value: 'homematic-ccu3' },
+        displayName: 'HomeMatic CCU3',
+        version: '1.0.0',
+        transport: ConnectorTransport.UNIX_SOCKET,
+        endpoint: '/run/kusinta/connectors/homematic.sock',
+        supportedDeviceTypeIds: [0x0301, 0x0302],
+      },
+      knownDevices: [{ deviceId: { value: 'dev-1' }, matterDeviceTypeId: 0x0301 }],
+    })
+    const decoded = fromBinary(ConnectorHandshakeSchema, toBinary(ConnectorHandshakeSchema, h))
+    expect(decoded.info?.connectorId?.value).toBe('homematic-ccu3')
+    expect(decoded.info?.displayName).toBe('HomeMatic CCU3')
+    expect(decoded.info?.transport).toBe(ConnectorTransport.UNIX_SOCKET)
+    expect(decoded.info?.supportedDeviceTypeIds).toEqual([0x0301, 0x0302])
+    expect(decoded.knownDevices).toHaveLength(1)
+    expect(decoded.knownDevices[0].deviceId?.value).toBe('dev-1')
+  })
+})
+
+describe('HandshakeAck', () => {
+  it('round-trips accepted ack', () => {
+    const ack = create(HandshakeAckSchema, { accepted: true, reason: '', gatewayId: { value: 'gw-abc' } })
+    const decoded = fromBinary(HandshakeAckSchema, toBinary(HandshakeAckSchema, ack))
+    expect(decoded.accepted).toBe(true)
+    expect(decoded.gatewayId?.value).toBe('gw-abc')
+  })
+
+  it('round-trips rejected ack with reason', () => {
+    const ack = create(HandshakeAckSchema, { accepted: false, reason: 'Unknown connector ID' })
+    const decoded = fromBinary(HandshakeAckSchema, toBinary(HandshakeAckSchema, ack))
+    expect(decoded.accepted).toBe(false)
+    expect(decoded.reason).toBe('Unknown connector ID')
+  })
+})
+
+describe('DeviceAnnouncement', () => {
+  it('round-trips descriptor', () => {
+    const ann = create(DeviceAnnouncementSchema, {
+      descriptor: { deviceId: { value: 'dev-new-1' }, matterDeviceTypeId: 0x0307, vendorName: 'eQ-3', productName: 'HmIP-STH' },
+    })
+    const decoded = fromBinary(DeviceAnnouncementSchema, toBinary(DeviceAnnouncementSchema, ann))
+    expect(decoded.descriptor?.deviceId?.value).toBe('dev-new-1')
+    expect(decoded.descriptor?.matterDeviceTypeId).toBe(0x0307)
+  })
+})
+
+describe('DeviceRemoval', () => {
+  it('round-trips device_id and reason', () => {
+    const rem = create(DeviceRemovalSchema, { deviceId: { value: 'dev-1' }, reason: 'Device unpaired from CCU3' })
+    const decoded = fromBinary(DeviceRemovalSchema, toBinary(DeviceRemovalSchema, rem))
+    expect(decoded.deviceId?.value).toBe('dev-1')
+    expect(decoded.reason).toBe('Device unpaired from CCU3')
+  })
+})
+
+describe('ConnectRequest oneof payload', () => {
+  it('round-trips handshake payload', () => {
+    const msg = create(ConnectRequestSchema, {
+      messageId: 'msg-001',
+      payload: {
+        case: 'handshake',
+        value: {
+          info: {
+            connectorId: { value: 'conn-1' },
+            displayName: 'Test Connector',
+            version: '0.1.0',
+            transport: ConnectorTransport.UNIX_SOCKET,
+            endpoint: '/run/test.sock',
+          },
+          knownDevices: [],
+        },
+      },
+    })
+    const decoded = fromBinary(ConnectRequestSchema, toBinary(ConnectRequestSchema, msg))
+    expect(decoded.messageId).toBe('msg-001')
+    expect(decoded.payload?.case).toBe('handshake')
+    if (decoded.payload?.case === 'handshake') {
+      expect(decoded.payload.value.info?.connectorId?.value).toBe('conn-1')
+    }
+  })
+
+  it('round-trips property_update payload', () => {
+    const msg = create(ConnectRequestSchema, {
+      messageId: 'msg-002',
+      payload: {
+        case: 'propertyUpdate',
+        value: {
+          updates: [{
+            deviceId: { value: 'dev-1' },
+            attributeName: 'OccupiedHeatingSetpoint',
+            value: { case: 'intValue', value: 2150 },
+            clusterIdHex: '0201',
+          }],
+        },
+      },
+    })
+    const decoded = fromBinary(ConnectRequestSchema, toBinary(ConnectRequestSchema, msg))
+    expect(decoded.payload?.case).toBe('propertyUpdate')
+    if (decoded.payload?.case === 'propertyUpdate') {
+      expect(decoded.payload.value.updates).toHaveLength(1)
+      expect(decoded.payload.value.updates[0].attributeName).toBe('OccupiedHeatingSetpoint')
+    }
+  })
+
+  it('round-trips heartbeat payload', () => {
+    const msg = create(ConnectRequestSchema, {
+      messageId: 'msg-hb-1',
+      payload: { case: 'heartbeat', value: {} },
+    })
+    const decoded = fromBinary(ConnectRequestSchema, toBinary(ConnectRequestSchema, msg))
+    expect(decoded.payload?.case).toBe('heartbeat')
+  })
+})
+
+describe('ConnectResponse oneof payload', () => {
+  it('round-trips handshake_ack payload', () => {
+    const msg = create(ConnectResponseSchema, {
+      messageId: 'gw-msg-001',
+      payload: { case: 'handshakeAck', value: { accepted: true, gatewayId: { value: 'gw-1' } } },
+    })
+    const decoded = fromBinary(ConnectResponseSchema, toBinary(ConnectResponseSchema, msg))
+    expect(decoded.payload?.case).toBe('handshakeAck')
+    if (decoded.payload?.case === 'handshakeAck') {
+      expect(decoded.payload.value.accepted).toBe(true)
+    }
+  })
+})

package/src/__tests__/device.test.js

@@ -0,0 +1,194 @@
+// @ts-check
+import { describe, it, expect } from 'vitest'
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf'
+import { DeviceDescriptorSchema } from '../kusinta/iot/device/v1/descriptor_pb.js'
+import { DeviceOwnershipType, DeviceLifecycleState } from '../kusinta/iot/common/v1/types_pb.js'
+import {
+  ThermostatPropertiesSchema,
+  TemperatureSensorPropertiesSchema,
+  WindowCoveringPropertiesSchema,
+  DoorLockPropertiesSchema,
+  ContactSensorPropertiesSchema,
+  OnOffLightPropertiesSchema,
+  DimmableLightPropertiesSchema,
+} from '../kusinta/iot/device/v1/properties_pb.js'
+import { DeviceSchema } from '../kusinta/iot/device/v1/device_pb.js'
+import { PropertyUpdateSchema, PropertyUpdateBatchSchema } from '../kusinta/iot/device/v1/property_update_pb.js'
+
+describe('DeviceDescriptor', () => {
+  it('round-trips matter_device_type_id for thermostat (0x0301 = 769)', () => {
+    const d = create(DeviceDescriptorSchema, {
+      deviceId: { value: 'dev-001' },
+      matterDeviceTypeId: 0x0301,
+      vendorName: 'eQ-3',
+      productName: 'HM-CC-RT-DN',
+      serialNumber: 'MEQ1234567',
+      nodeLabel: 'Living room thermostat',
+      vendorId: 0x0135,
+      productId: 0x0095,
+      hardwareVersionString: '1.4',
+      softwareVersionString: '2.8.0',
+      connectorId: { value: 'homematic-ccu3' },
+      spaceId: { value: 'room-uuid' },
+      ownership: DeviceOwnershipType.COMPANY,
+      lifecycle: DeviceLifecycleState.OWNED,
+    })
+    const decoded = fromBinary(DeviceDescriptorSchema, toBinary(DeviceDescriptorSchema, d))
+    expect(decoded.matterDeviceTypeId).toBe(0x0301)
+    expect(decoded.vendorName).toBe('eQ-3')
+    expect(decoded.ownership).toBe(DeviceOwnershipType.COMPANY)
+  })
+
+  it('round-trips resident-owned lifecycle', () => {
+    const d = create(DeviceDescriptorSchema, {
+      deviceId: { value: 'dev-resident-001' },
+      matterDeviceTypeId: 0x0100,
+      ownership: DeviceOwnershipType.RESIDENT,
+      lifecycle: DeviceLifecycleState.PENDING_CLAIM,
+      ownerUserId: { value: 'user-abc' },
+    })
+    const decoded = fromBinary(DeviceDescriptorSchema, toBinary(DeviceDescriptorSchema, d))
+    expect(decoded.ownership).toBe(DeviceOwnershipType.RESIDENT)
+    expect(decoded.lifecycle).toBe(DeviceLifecycleState.PENDING_CLAIM)
+    expect(decoded.ownerUserId?.value).toBe('user-abc')
+  })
+})
+
+describe('ThermostatProperties — Matter Thermostat cluster 0x0201', () => {
+  it('round-trips occupied_heating_setpoint (21.50°C = 2150 centidegrees)', () => {
+    const p = create(ThermostatPropertiesSchema, { occupiedHeatingSetpoint: 2150 })
+    const decoded = fromBinary(ThermostatPropertiesSchema, toBinary(ThermostatPropertiesSchema, p))
+    expect(decoded.occupiedHeatingSetpoint).toBe(2150)
+  })
+
+  it('preserves negative local_temperature (frost: -5.00°C = -500)', () => {
+    const p = create(ThermostatPropertiesSchema, { localTemperature: -500 })
+    const decoded = fromBinary(ThermostatPropertiesSchema, toBinary(ThermostatPropertiesSchema, p))
+    expect(decoded.localTemperature).toBe(-500)
+  })
+
+  it('round-trips min/max setpoint limits (property-owner constraints)', () => {
+    const p = create(ThermostatPropertiesSchema, { minHeatSetpointLimit: 1600, maxHeatSetpointLimit: 2200 })
+    const decoded = fromBinary(ThermostatPropertiesSchema, toBinary(ThermostatPropertiesSchema, p))
+    expect(decoded.minHeatSetpointLimit).toBe(1600)
+    expect(decoded.maxHeatSetpointLimit).toBe(2200)
+  })
+
+  it('round-trips system_mode enum values', () => {
+    const p = create(ThermostatPropertiesSchema, { systemMode: 4 }) // Heat=4
+    const decoded = fromBinary(ThermostatPropertiesSchema, toBinary(ThermostatPropertiesSchema, p))
+    expect(decoded.systemMode).toBe(4)
+  })
+})
+
+describe('TemperatureSensorProperties — Matter Temperature Measurement 0x0402', () => {
+  it('round-trips measured_value', () => {
+    const p = create(TemperatureSensorPropertiesSchema, { measuredValue: 2100 })
+    const decoded = fromBinary(TemperatureSensorPropertiesSchema, toBinary(TemperatureSensorPropertiesSchema, p))
+    expect(decoded.measuredValue).toBe(2100)
+  })
+})
+
+describe('WindowCoveringProperties — Matter Window Covering 0x0102', () => {
+  it('round-trips position as percent100ths (50% open = 5000)', () => {
+    const p = create(WindowCoveringPropertiesSchema, { currentPositionLiftPercent100ths: 5000 })
+    const decoded = fromBinary(WindowCoveringPropertiesSchema, toBinary(WindowCoveringPropertiesSchema, p))
+    expect(decoded.currentPositionLiftPercent100ths).toBe(5000)
+  })
+})
+
+describe('DoorLockProperties — Matter Door Lock 0x0101', () => {
+  it('round-trips lock_state (Locked=1)', () => {
+    const p = create(DoorLockPropertiesSchema, { lockState: 1 })
+    const decoded = fromBinary(DoorLockPropertiesSchema, toBinary(DoorLockPropertiesSchema, p))
+    expect(decoded.lockState).toBe(1)
+  })
+})
+
+describe('ContactSensorProperties — Matter Boolean State 0x0045', () => {
+  it('round-trips state_value false (contact open = alarm)', () => {
+    const p = create(ContactSensorPropertiesSchema, { stateValue: false })
+    const decoded = fromBinary(ContactSensorPropertiesSchema, toBinary(ContactSensorPropertiesSchema, p))
+    expect(decoded.stateValue).toBe(false)
+  })
+})
+
+describe('OnOffLightProperties — Matter On/Off 0x0006', () => {
+  it('round-trips on_off true', () => {
+    const p = create(OnOffLightPropertiesSchema, { onOff: true })
+    const decoded = fromBinary(OnOffLightPropertiesSchema, toBinary(OnOffLightPropertiesSchema, p))
+    expect(decoded.onOff).toBe(true)
+  })
+})
+
+describe('DimmableLightProperties — Matter Level Control 0x0008', () => {
+  it('round-trips current_level (0–254)', () => {
+    const p = create(DimmableLightPropertiesSchema, { onOff: true, currentLevel: 127 })
+    const decoded = fromBinary(DimmableLightPropertiesSchema, toBinary(DimmableLightPropertiesSchema, p))
+    expect(decoded.currentLevel).toBe(127)
+  })
+})
+
+describe('Device oneof properties', () => {
+  it('stores thermostat properties in the oneof', () => {
+    const d = create(DeviceSchema, {
+      descriptor: { deviceId: { value: 'therm-1' }, matterDeviceTypeId: 0x0301 },
+      properties: { case: 'thermostat', value: { occupiedHeatingSetpoint: 2000 } },
+    })
+    const decoded = fromBinary(DeviceSchema, toBinary(DeviceSchema, d))
+    expect(decoded.properties?.case).toBe('thermostat')
+    if (decoded.properties?.case === 'thermostat') {
+      expect(decoded.properties.value.occupiedHeatingSetpoint).toBe(2000)
+    }
+  })
+
+  it('stores temperature sensor properties in the oneof', () => {
+    const d = create(DeviceSchema, {
+      descriptor: { deviceId: { value: 'temp-1' }, matterDeviceTypeId: 0x0302 },
+      properties: { case: 'temperatureSensor', value: { measuredValue: 1950 } },
+    })
+    const decoded = fromBinary(DeviceSchema, toBinary(DeviceSchema, d))
+    expect(decoded.properties?.case).toBe('temperatureSensor')
+  })
+})
+
+describe('PropertyUpdate', () => {
+  it('round-trips int_value for thermostat setpoint', () => {
+    const u = create(PropertyUpdateSchema, {
+      deviceId: { value: 'therm-1' },
+      attributeName: 'OccupiedHeatingSetpoint',
+      value: { case: 'intValue', value: 2150 },
+      clusterIdHex: '0201',
+    })
+    const decoded = fromBinary(PropertyUpdateSchema, toBinary(PropertyUpdateSchema, u))
+    expect(decoded.attributeName).toBe('OccupiedHeatingSetpoint')
+    expect(decoded.value?.case).toBe('intValue')
+    if (decoded.value?.case === 'intValue') expect(decoded.value.value).toBe(2150)
+  })
+
+  it('round-trips bool_value for on/off light', () => {
+    const u = create(PropertyUpdateSchema, {
+      deviceId: { value: 'light-1' },
+      attributeName: 'OnOff',
+      value: { case: 'boolValue', value: true },
+      clusterIdHex: '0006',
+    })
+    const decoded = fromBinary(PropertyUpdateSchema, toBinary(PropertyUpdateSchema, u))
+    expect(decoded.value?.case).toBe('boolValue')
+    if (decoded.value?.case === 'boolValue') expect(decoded.value.value).toBe(true)
+  })
+})
+
+describe('PropertyUpdateBatch', () => {
+  it('round-trips multiple updates', () => {
+    const batch = create(PropertyUpdateBatchSchema, {
+      updates: [
+        { deviceId: { value: 'd1' }, attributeName: 'LocalTemperature', value: { case: 'intValue', value: 1900 } },
+        { deviceId: { value: 'd1' }, attributeName: 'OccupiedHeatingSetpoint', value: { case: 'intValue', value: 2100 } },
+      ],
+    })
+    const decoded = fromBinary(PropertyUpdateBatchSchema, toBinary(PropertyUpdateBatchSchema, batch))
+    expect(decoded.updates.length).toBe(2)
+    expect(decoded.updates[0].attributeName).toBe('LocalTemperature')
+  })
+})

package/src/__tests__/identity.test.js

@@ -0,0 +1,43 @@
+// @ts-check
+import { describe, it, expect } from 'vitest'
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf'
+import {
+  DeviceIdSchema,
+  GatewayIdSchema,
+  UserIdSchema,
+  SpaceIdSchema,
+  ConnectorIdSchema,
+  TenantIdSchema,
+} from '../kusinta/iot/identity/v1/identity_pb.js'
+
+describe('Identity wrapper types', () => {
+  it('DeviceId round-trips value', () => {
+    const id = create(DeviceIdSchema, { value: 'device-abc-123' })
+    expect(fromBinary(DeviceIdSchema, toBinary(DeviceIdSchema, id)).value).toBe('device-abc-123')
+  })
+
+  it('GatewayId round-trips value', () => {
+    const id = create(GatewayIdSchema, { value: 'gw-hmac-sha256-result' })
+    expect(fromBinary(GatewayIdSchema, toBinary(GatewayIdSchema, id)).value).toBe('gw-hmac-sha256-result')
+  })
+
+  it('UserId round-trips value', () => {
+    const id = create(UserIdSchema, { value: 'user-keycloak-sub' })
+    expect(fromBinary(UserIdSchema, toBinary(UserIdSchema, id)).value).toBe('user-keycloak-sub')
+  })
+
+  it('SpaceId round-trips value', () => {
+    const id = create(SpaceIdSchema, { value: 'space-uuid-v4' })
+    expect(fromBinary(SpaceIdSchema, toBinary(SpaceIdSchema, id)).value).toBe('space-uuid-v4')
+  })
+
+  it('ConnectorId round-trips value', () => {
+    const id = create(ConnectorIdSchema, { value: 'homematic-ccu3' })
+    expect(fromBinary(ConnectorIdSchema, toBinary(ConnectorIdSchema, id)).value).toBe('homematic-ccu3')
+  })
+
+  it('TenantId round-trips value', () => {
+    const id = create(TenantIdSchema, { value: 'tenant-property-co' })
+    expect(fromBinary(TenantIdSchema, toBinary(TenantIdSchema, id)).value).toBe('tenant-property-co')
+  })
+})

package/src/__tests__/space.test.js

@@ -0,0 +1,54 @@
+// @ts-check
+import { describe, it, expect } from 'vitest'
+import { create, toBinary, fromBinary } from '@bufbuild/protobuf'
+import { SpaceType } from '../kusinta/iot/common/v1/types_pb.js'
+import { SpaceSchema } from '../kusinta/iot/space/v1/space_pb.js'
+
+describe('Space', () => {
+  it('round-trips a building with sub-spaces', () => {
+    const building = create(SpaceSchema, {
+      spaceId: { value: 'building-1' },
+      spaceType: SpaceType.BUILDING,
+      name: 'Storgatan 5',
+      tenantId: { value: 'tenant-1' },
+      gatewayId: { value: 'gw-1' },
+      subSpaceIds: [{ value: 'floor-1' }, { value: 'floor-2' }],
+    })
+    const decoded = fromBinary(SpaceSchema, toBinary(SpaceSchema, building))
+    expect(decoded.spaceId?.value).toBe('building-1')
+    expect(decoded.spaceType).toBe(SpaceType.BUILDING)
+    expect(decoded.name).toBe('Storgatan 5')
+    expect(decoded.subSpaceIds).toHaveLength(2)
+    expect(decoded.subSpaceIds[0].value).toBe('floor-1')
+  })
+
+  it('round-trips an apartment with resident', () => {
+    const apt = create(SpaceSchema, {
+      spaceId: { value: 'apt-101' },
+      spaceType: SpaceType.APARTMENT,
+      name: 'Lgh 101',
+      floor: 1,
+      parentSpaceId: { value: 'floor-1' },
+      residentUserId: { value: 'user-resident-1' },
+      deviceIds: [{ value: 'therm-1' }, { value: 'temp-sensor-1' }],
+    })
+    const decoded = fromBinary(SpaceSchema, toBinary(SpaceSchema, apt))
+    expect(decoded.spaceType).toBe(SpaceType.APARTMENT)
+    expect(decoded.floor).toBe(1)
+    expect(decoded.parentSpaceId?.value).toBe('floor-1')
+    expect(decoded.residentUserId?.value).toBe('user-resident-1')
+    expect(decoded.deviceIds).toHaveLength(2)
+  })
+
+  it('round-trips a room', () => {
+    const room = create(SpaceSchema, {
+      spaceId: { value: 'room-living' },
+      spaceType: SpaceType.ROOM,
+      name: 'Living Room',
+      parentSpaceId: { value: 'apt-101' },
+    })
+    const decoded = fromBinary(SpaceSchema, toBinary(SpaceSchema, room))
+    expect(decoded.spaceType).toBe(SpaceType.ROOM)
+    expect(decoded.name).toBe('Living Room')
+  })
+})