fix(lwm2m): allow timestamps in the future of up to 60 seconds

Some devices clocks drift so that they report
a timestamp a few seconds in the future.

This change allows the offset to be up to 60
seconds.

Author: coderbyheart

historicalData/instanceToMeasures.ts

@@ -7,6 +7,8 @@ import {
 	timestampResources,
 	type LwM2MObjectInstance,
 } from '@hello.nrfcloud.com/proto-map/lwm2m'
+import { isNumber } from 'lodash-es'
+import { correctOffset } from '../lwm2m/correctOffset.js'
 import { InvalidTimeError } from '../lwm2m/InvalidTimeError.js'
 import { isNumeric } from '../lwm2m/isNumeric.js'
 import { isUnixTimeInSeconds } from '../lwm2m/isUnixTimeInSeconds.js'
@@ -30,7 +32,16 @@ export const instanceToMeasures = ({
 		}
 	}
 
-	if (!isUnixTimeInSeconds(ts)) {
+	if (!isNumber(ts)) {
+		return {
+			error: new InvalidTimeError(
+				`Not a timestamp resource defined for ${ObjectID}: ${ts.toString()}!`,
+			),
+		}
+	}
+	const correctedTs = correctOffset(ts)
+
+	if (!isUnixTimeInSeconds(correctedTs)) {
 		return {
 			error: new InvalidTimeError(
 				`Timestamp ${JSON.stringify(ts)} for ${ObjectID} is not a valid unix time in seconds!`,

lwm2m/correctOffset.spec.ts

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { correctOffset } from './correctOffset.js'
+import { isUnixTimeInSeconds } from './isUnixTimeInSeconds.js'
+
+void describe('correctOffset()', () => {
+	void it('should correct timestamps in the future of up to 60 seconds', () => {
+		assert.equal(
+			isUnixTimeInSeconds(correctOffset(Date.now() / 1000 + 1)),
+			true,
+			'should correct 1 second in the future',
+		)
+		assert.equal(
+			isUnixTimeInSeconds(correctOffset(Date.now() / 1000 + 60)),
+			true,
+			'should correct 60 seconds in the future',
+		)
+		assert.equal(
+			isUnixTimeInSeconds(correctOffset(Date.now() / 1000 + 61)),
+			false,
+			'should not correct 61 seconds in the future',
+		)
+	})
+})

lwm2m/correctOffset.ts

@@ -0,0 +1,12 @@
+/**
+ * Corrects an offset of up to 60 seconds in the future.
+ * This is needed because some devices clocks drift, and they report timestamps in the future.
+ */
+export const correctOffset = (ts: number, maxOffsetSeconds = 60): number => {
+	const nowSeconds = Math.ceil(Date.now() / 1000)
+	const offset = ts * 1000 - nowSeconds
+	if (offset < 0) {
+		return ts
+	}
+	return ts - Math.min(offset, maxOffsetSeconds)
+}

lwm2m/isUnixTimeInSeconds.ts

@@ -1,5 +1,7 @@
+import { isNumber } from 'lodash-es'
+
 export const isUnixTimeInSeconds = (value: unknown): value is number => {
-	if (typeof value !== 'number') return false
+	if (!isNumber(value)) return false
 	if (value < 1700000000) return false
 	if (value * 1000 > Date.now()) return false
 	return true