fix: decode getEventInformation ack and allow optional object filter (#68)

## Summary
This PR consolidates event/alarm fixes in `getEventInformation`:
- decode ACK payload using the correct decoder path
- support optional `objectId` filter (`null` allowed)
- harden decode loop for tagged timestamps and closing-tag termination

## Problem
Event/alarm handling could fail or return incomplete data because:
- ACK payload decode path was incorrect
- calls without object filter were not supported
- decoder could break on valid tagged timestamp/closing-tag patterns

## Changes
- `src/lib/client.ts`
  - updated `getEventInformation(...)` to accept optional `objectId`
  - encode object-id context tag only when provided
  - decode response with `GetEventInformation.decodeAcknowledge(...)`
  - return `result.events`
- `src/lib/services/EventInformation.ts`
- hardened decoder iteration/termination for tagged timestamp structures

## Impact
- More robust `getEventInformation` behavior across BACnet devices
- Works with both filtered and unfiltered queries
- Improves reliability for event/alarm pipelines downstream

## Compatibility
Backward compatible. No public API break.

## Validation
Verified with real gateway flow:
- event/alarm fetch succeeds without object filter
- decoded events are returned consistently
- downstream event handling receives expected payload structure

---------

Co-authored-by: Daniel Lando <daniel.sorridi@gmail.com>

Author: EveGun

src/lib/client.ts

@@ -17,6 +17,7 @@ import ServicesMap, {
 	DeleteObject,
 	DeviceCommunicationControl,
 	EventInformation,
+	GetEventInformation,
 	EventNotifyData,
 	GetEnrollmentSummary,
 	IAm,
@@ -1776,7 +1777,7 @@ export default class BACnetClient extends TypedEventEmitter<BACnetClientEvents>
 	 */
 	async getEventInformation(
 		receiver: BACNetAddress,
-		objectId: BACNetObjectID,
+		objectId?: BACNetObjectID | null,
 		options: ServiceOptions = {},
 	): Promise<BACNetEventInformation[]> {
 		const settings: ServiceOptions = {
@@ -1805,23 +1806,25 @@ export default class BACnetClient extends TypedEventEmitter<BACnetClientEvents>
 			0,
 			0,
 		)
-		baAsn1.encodeContextObjectId(
-			buffer,
-			0,
-			objectId.type,
-			objectId.instance,
-		)
+		if (objectId) {
+			baAsn1.encodeContextObjectId(
+				buffer,
+				0,
+				objectId.type,
+				objectId.instance,
+			)
+		}
 		this.sendBvlc(receiver, buffer)
 		const data = await this._requestManager.add(settings.invokeId)
-		const result = EventInformation.decode(
+		const result = GetEventInformation.decodeAcknowledge(
 			data.buffer,
 			data.offset,
 			data.length,
 		)
 		if (!result) {
 			throw new Error('INVALID_DECODING')
 		}
-		return result.alarms
+		return result.events
 	}
 
 	/**

src/lib/services/EventInformation.ts

@@ -1,5 +1,4 @@
 import * as baAsn1 from '../asn1'
-import { ApplicationTag } from '../enum'
 import { EncodeBuffer, BACNetEvent } from '../types'
 import { BacnetService } from './AbstractServices'
 
@@ -51,7 +50,10 @@ export default class EventInformation extends BacnetService {
 		len++
 		const alarms = []
 
-		while (apduLen - 3 - len > 0) {
+		while (
+			len < apduLen &&
+			!baAsn1.decodeIsClosingTagNumber(buffer, offset + len, 0)
+		) {
 			const value: any = {}
 
 			result = baAsn1.decodeTagNumberAndValue(buffer, offset + len)
@@ -88,31 +90,21 @@ export default class EventInformation extends BacnetService {
 			value.eventTimeStamps = []
 
 			for (let i = 0; i < 3; i++) {
-				if (result.tagNumber !== ApplicationTag.NULL) {
-					decodedValue = baAsn1.decodeApplicationDate(
-						buffer,
-						offset + len,
-					)
-					len += decodedValue.len
-					const date = decodedValue.value
-					decodedValue = baAsn1.decodeApplicationTime(
-						buffer,
-						offset + len,
-					)
-					len += decodedValue.len
-					const time = decodedValue.value
-					value.eventTimeStamps[i] = new Date(
-						date.getFullYear(),
-						date.getMonth(),
-						date.getDate(),
-						time.getHours(),
-						time.getMinutes(),
-						time.getSeconds(),
-						time.getMilliseconds(),
-					)
-				} else {
-					len += result.value
-				}
+				decodedValue = baAsn1.decodeApplicationDate(buffer, offset + len)
+				len += decodedValue.len
+				const date = decodedValue.value
+				decodedValue = baAsn1.decodeApplicationTime(buffer, offset + len)
+				len += decodedValue.len
+				const time = decodedValue.value
+				value.eventTimeStamps[i] = new Date(
+					date.getFullYear(),
+					date.getMonth(),
+					date.getDate(),
+					time.getHours(),
+					time.getMinutes(),
+					time.getSeconds(),
+					time.getMilliseconds(),
+				)
 			}
 
 			len++

test/unit/client.spec.ts

@@ -2,7 +2,10 @@ import test from 'node:test'
 import assert from 'node:assert'
 
 import BACnetClient from '../../src/lib/client'
-import { ServicesSupported } from '../../src'
+import * as baNpdu from '../../src/lib/npdu'
+import * as baApdu from '../../src/lib/apdu'
+import { GetEventInformation } from '../../src/lib/services'
+import { EventState, NotifyType, ServicesSupported, TimeStamp } from '../../src'
 
 test.describe('bacnet - client', () => {
 	test('should successfuly encode a bitstring > 32 bits', () => {
@@ -36,4 +39,81 @@ test.describe('bacnet - client', () => {
 			bitsUsed: 1,
 		})
 	})
+
+	test('getEventInformation should omit optional objectId when not provided', async () => {
+		const client = Object.create(BACnetClient.prototype) as BACnetClient & {
+			_requestManager: { add: (invokeId: number) => Promise<any> }
+			_getInvokeId: () => number
+			_getApduBuffer: () => { buffer: Buffer; offset: number }
+			sendBvlc: (
+				receiver: { address: string } | null,
+				buffer: { buffer: Buffer; offset: number },
+			) => void
+		}
+
+		const response = {
+			buffer: Buffer.alloc(1482),
+			offset: 0,
+		}
+		GetEventInformation.encodeAcknowledge(
+			response,
+			[
+				{
+					objectId: { type: 0, instance: 32 },
+					eventState: EventState.NORMAL,
+					acknowledgedTransitions: { value: [14], bitsUsed: 6 },
+					eventTimeStamps: [
+						{ type: TimeStamp.SEQUENCE_NUMBER, value: 1 },
+						{ type: TimeStamp.SEQUENCE_NUMBER, value: 2 },
+						{ type: TimeStamp.SEQUENCE_NUMBER, value: 3 },
+					],
+					notifyType: NotifyType.EVENT,
+					eventEnable: { value: [15], bitsUsed: 7 },
+					eventPriorities: [2, 3, 4],
+				},
+			],
+			false,
+		)
+		const expected = GetEventInformation.decodeAcknowledge(
+			response.buffer,
+			0,
+			response.offset,
+		)
+		assert.ok(expected)
+
+		let sentRequest: Buffer | undefined
+		client._getInvokeId = () => 7
+		client._getApduBuffer = () => ({
+			buffer: Buffer.alloc(1482),
+			offset: 4,
+		})
+		client.sendBvlc = (_receiver, buffer) => {
+			sentRequest = Buffer.from(buffer.buffer.subarray(0, buffer.offset))
+		}
+		client._requestManager = {
+			add: async (invokeId: number) => {
+				assert.strictEqual(invokeId, 7)
+				return {
+					buffer: response.buffer,
+					offset: 0,
+					length: response.offset,
+				}
+			},
+		}
+
+		const events = await client.getEventInformation({
+			address: '127.0.0.1',
+		})
+
+		assert.ok(sentRequest)
+		const npdu = baNpdu.decode(sentRequest, 4)
+		assert.ok(npdu)
+		const apdu = baApdu.decodeConfirmedServiceRequest(
+			sentRequest,
+			4 + npdu.len,
+		)
+		const payloadOffset = 4 + npdu.len + apdu.len
+		assert.strictEqual(payloadOffset, sentRequest.length)
+		assert.deepStrictEqual(events, expected.events)
+	})
 })