@hello.nrfcloud.com/proto-map 16.1.40 → 16.2.0

package/lwm2m/aws/instanceToMeasures.ts

@@ -0,0 +1,72 @@
+import {
+	MeasureValueType,
+	type MeasureValue,
+} from '@aws-sdk/client-timestream-write'
+import { correctOffset } from 'lwm2m/correctOffset.js'
+import { definitions } from 'lwm2m/definitions.js'
+import { InvalidTimeError } from 'lwm2m/InvalidTimeError.js'
+import { isNumber } from 'lwm2m/isNumber.js'
+import { isNumeric } from 'lwm2m/isNumeric.js'
+import { isUnixTimeInSeconds } from 'lwm2m/isUnixTimeInSeconds.js'
+import type { LwM2MObjectInstance } from 'lwm2m/LwM2MObjectInstance.js'
+import { timestampResources } from 'lwm2m/timestampResources.js'
+
+export const instanceToMeasures = ({
+	Resources,
+	ObjectID,
+	ObjectInstanceID,
+	ObjectVersion,
+}: LwM2MObjectInstance): { measures: MeasureValue[] } | { error: Error } => {
+	const measures: MeasureValue[] = []
+
+	const tsResource = timestampResources.get(ObjectID) as number
+	const ts = Resources[tsResource]
+
+	if (ts === undefined) {
+		return {
+			error: new InvalidTimeError(
+				`No timestamp resource defined for ${ObjectID}!`,
+			),
+		}
+	}
+
+	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!`,
+			),
+		}
+	}
+
+	for (const [ResourceID, Value] of Object.entries(Resources)) {
+		const def = definitions[ObjectID].Resources[parseInt(ResourceID, 10)]
+		if (def === undefined) {
+			return {
+				error: new Error(
+					`No definition found for ${ObjectID}/${ObjectInstanceID}/${ResourceID}`,
+				),
+			}
+		}
+
+		if (Value === null) continue
+		if (Value === undefined) continue
+
+		if (!isNumeric(def)) continue
+
+		measures.push({
+			Name: `${ObjectID}/${ObjectVersion}/${ResourceID}`,
+			Value: Value.toString(),
+			Type: MeasureValueType.DOUBLE,
+		})
+	}
+	return { measures }
+}

package/lwm2m/aws/objectsToShadow.spec.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
-import { objectsToShadow } from './objectsToShadow.js'
 import { LwM2MObjectID } from '../LwM2MObjectID.js'
+import { objectsToShadow } from './objectsToShadow.js'
 
 void describe('objectsToShadow()', () => {
 	void it('should convert a list of LwM2M objects to a shadow document', () =>
@@ -45,7 +45,7 @@ void describe('objectsToShadow()', () => {
 					ObjectVersion: '1.0',
 					Resources: {
 						0: ['BOOT', 'MODEM', 'APP'],
-						99: 1717409966 * 1000,
+						99: 1717409966,
 					},
 				},
 			]),
@@ -83,7 +83,7 @@ void describe('objectsToShadow()', () => {
 				'14401:1.0': {
 					0: {
 						0: ['BOOT', 'MODEM', 'APP'],
-						99: 1717409966 * 1000,
+						99: 1717409966,
 					},
 				},
 			},

package/lwm2m/aws/shadowToObjects.spec.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import { describe, it } from 'node:test'
-import { shadowToObjects } from './shadowToObjects.js'
 import { LwM2MObjectID } from '../LwM2MObjectID.js'
+import { shadowToObjects } from './shadowToObjects.js'
 
 void describe('shadowToObjects()', () => {
 	void it('should convert a shadow to LwM2M objects', () =>
@@ -44,7 +44,7 @@ void describe('shadowToObjects()', () => {
 				'14401:1.0': {
 					0: {
 						0: ['BOOT', 'MODEM', 'APP'],
-						99: 1717409966 * 1000,
+						99: 1717409966,
 					},
 				},
 			}),
@@ -99,7 +99,7 @@ void describe('shadowToObjects()', () => {
 					ObjectVersion: '1.0',
 					Resources: {
 						0: ['BOOT', 'MODEM', 'APP'],
-						99: 1717409966 * 1000,
+						99: 1717409966,
 					},
 				},
 			],

package/lwm2m/aws/shadowToObjects.ts

@@ -1,6 +1,6 @@
 import type { LwM2MObjectInstance } from '../LwM2MObjectInstance.js'
-import type { LwM2MShadow } from './objectsToShadow.js'
 import { timestampResources } from '../timestampResources.js'
+import type { LwM2MShadow } from './objectsToShadow.js'
 
 export const shadowToObjects = (shadow: LwM2MShadow): LwM2MObjectInstance[] =>
 	Object.entries(shadow)

package/lwm2m/check-lwm2m-rules.ts

@@ -1,17 +1,17 @@
 import chalk from 'chalk'
+import assert from 'node:assert/strict'
+import { exec } from 'node:child_process'
 import { readFile, readdir, stat } from 'node:fs/promises'
 import path, { parse } from 'node:path'
-import assert from 'node:assert/strict'
 import xml2js from 'xml2js'
-import { exec } from 'node:child_process'
-import { unwrapNestedArray } from './unwrapNestedArray.js'
+import { validate } from '../validate.js'
 import {
 	LWM2MObjectDefinition,
 	type LWM2MObjectDefinitionType,
 } from './LWM2MObjectDefinition.js'
 import type { ParsedLwM2MObjectDefinition } from './ParsedLwM2MObjectDefinition.js'
-import { validate } from '../validate.js'
 import { parseRangeEnumeration } from './parseRangeEnumeration.js'
+import { unwrapNestedArray } from './unwrapNestedArray.js'
 
 const v = validate(LWM2MObjectDefinition)
 

package/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',
+		)
+	})
+})

package/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)
+}

package/lwm2m/fromXML2JSON.ts

@@ -1,6 +1,6 @@
-import xml2js from 'xml2js'
 import { readFile } from 'node:fs/promises'
 import path from 'node:path'
+import xml2js from 'xml2js'
 import type { LwM2MType } from './resourceType.js'
 
 /**

package/lwm2m/index.ts

@@ -1,11 +1,15 @@
-export * from './validate.js'
-export * from './timestampResources.js'
+export * from './definitions.js'
+export * from './instanceTs.js'
+export * from './InvalidTimeError.js'
+export * from './isLwM2MObjectID.js'
+export * from './isNumber.js'
+export * from './isNumeric.js'
+export * from './isUnixTimeInSeconds.js'
 export * from './LwM2MObject.js'
 export * from './LwM2MObjectID.js'
-export * from './objects.js'
-export * from './definitions.js'
 export * from './LWM2MObjectInfo.js'
-export * from './validators.js'
-export * from './instanceTs.js'
 export * from './LwM2MObjectInstance.js'
-export * from './isLwM2MObjectID.js'
+export * from './objects.js'
+export * from './timestampResources.js'
+export * from './validate.js'
+export * from './validators.js'

package/lwm2m/instanceTs.spec.ts

@@ -1,5 +1,5 @@
-import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
 import { instanceTs, instanceTsAsDate } from './instanceTs.js'
 
 void describe('instanceTs()', () => {

package/lwm2m/isNumber.ts

@@ -0,0 +1,2 @@
+export const isNumber = (value: unknown): value is number =>
+	Number.isFinite(value)

package/lwm2m/isNumeric.spec.ts

@@ -0,0 +1,30 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { isNumeric } from './isNumeric.js'
+import { ResourceType } from './LWM2MObjectInfo.js'
+
+void describe('isNumeric', () => {
+	void it('should return true for numeric types', () => {
+		const numericTypes = [
+			{ Type: ResourceType.Float },
+			{ Type: ResourceType.Integer },
+		]
+
+		numericTypes.forEach((def) => {
+			assert.strictEqual(isNumeric(def), true)
+		})
+	})
+
+	void it('should return false for non-numeric types', () => {
+		const nonNumericTypes = [
+			{ Type: ResourceType.String },
+			{ Type: ResourceType.Opaque },
+			{ Type: ResourceType.Boolean },
+			{ Type: ResourceType.Time },
+		]
+
+		nonNumericTypes.forEach((def) => {
+			assert.strictEqual(isNumeric(def), false)
+		})
+	})
+})

package/lwm2m/isNumeric.ts

@@ -0,0 +1,17 @@
+import { ResourceType } from './LWM2MObjectInfo.js'
+
+/**
+ * Only store numeric values, because you cannot create statistics about strings, or boolean
+ */
+export const isNumeric = (def: { Type: ResourceType }): boolean => {
+	switch (def.Type) {
+		case ResourceType.Float:
+		case ResourceType.Integer:
+			return true
+		case ResourceType.String:
+		case ResourceType.Opaque:
+		case ResourceType.Boolean:
+		case ResourceType.Time: // Time is numeric, but is stored as timestamp
+			return false
+	}
+}

package/lwm2m/isUnixTimeInSeconds.spec.ts

@@ -0,0 +1,16 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { isUnixTimeInSeconds } from './isUnixTimeInSeconds.js'
+
+void describe('isUnixTimeInSeconds()', () => {
+	void it('should return true for valid Unix time in seconds', () => {
+		assert.equal(isUnixTimeInSeconds(1700000000), true)
+		assert.equal(isUnixTimeInSeconds(Date.now() / 1000), true)
+	})
+
+	void it('should return false for invalid Unix time in seconds', () => {
+		assert.equal(isUnixTimeInSeconds('1700000000'), false)
+		assert.equal(isUnixTimeInSeconds(1699999999), false)
+		assert.equal(isUnixTimeInSeconds(Date.now()), false)
+	})
+})

package/lwm2m/isUnixTimeInSeconds.ts

@@ -0,0 +1,8 @@
+import { isNumber } from './isNumber.js'
+
+export const isUnixTimeInSeconds = (value: unknown): value is number => {
+	if (!isNumber(value)) return false
+	if (value < 1700000000) return false
+	if (value * 1000 > Date.now()) return false
+	return true
+}

package/lwm2m/parseRangeEnumeration.spec.ts

@@ -1,7 +1,7 @@
-import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import { parseRangeEnumeration } from './parseRangeEnumeration.js'
+import { describe, it } from 'node:test'
 import { RangeEnumerationRegExp } from './LWM2MObjectDefinition.js'
+import { parseRangeEnumeration } from './parseRangeEnumeration.js'
 
 void describe('parseRangeEnumeration()', () => {
 	void it('should parse valid range enumeration', () => {

package/lwm2m/unwrapNestedArray.spec.ts

@@ -1,5 +1,5 @@
-import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
 import { unwrapNestedArray } from './unwrapNestedArray.js'
 
 void describe('unwrapNestedArray()', () => {

package/lwm2m/validate.spec.ts

@@ -1,7 +1,7 @@
+import assert from 'node:assert'
 import { describe, it } from 'node:test'
 import { validate } from './validate.js'
 import { validators } from './validators.js'
-import assert from 'node:assert'
 
 void describe('validate()', () => {
 	const v = validate(validators)

package/lwm2m/validate.ts

@@ -1,5 +1,5 @@
-import type { LwM2MObjectInstance } from './LwM2MObjectInstance.js'
 import type { LwM2MObjectID } from './LwM2MObjectID.js'
+import type { LwM2MObjectInstance } from './LwM2MObjectInstance.js'
 import { isLwM2MObject } from './validation.js'
 
 export const validate =

package/lwm2m/validation.ts

@@ -1,5 +1,5 @@
-import type { LwM2MObjectInstance } from './LwM2MObjectInstance.js'
 import { LwM2MObjectIDs, type LwM2MObjectID } from './LwM2MObjectID.js'
+import type { LwM2MObjectInstance } from './LwM2MObjectInstance.js'
 
 export const isLwM2MObject = (
 	object: unknown,

package/models/check-model-rules.ts

@@ -1,9 +1,9 @@
 import chalk from 'chalk'
+import { parseREADME } from 'markdown/parseREADME.js'
 import assert from 'node:assert/strict'
 import { readFile, readdir, stat } from 'node:fs/promises'
 import path from 'node:path'
 import { ModelIDRegExp } from './types.js'
-import { parseREADME } from 'markdown/parseREADME.js'
 
 console.log(chalk.gray('Models rules check'))
 console.log('')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hello.nrfcloud.com/proto-map",
-  "version": "16.1.40",
+  "version": "16.2.0",
   "description": "Documents the communication protocol between devices, the hello.nrfcloud.com/map backend and web application",
   "type": "module",
   "exports": {
@@ -39,7 +39,7 @@
     "@bifravst/prettier-config": "1.1.6",
     "@commitlint/config-conventional": "19.7.1",
     "@swc/cli": "0.6.0",
-    "@swc/core": "1.10.16",
+    "@swc/core": "1.10.18",
     "@types/node": "22.13.4",
     "@types/xml2js": "0.4.14",
     "chalk": "5.4.1",
@@ -49,7 +49,7 @@
     "remark": "15.0.1",
     "remark-frontmatter": "5.0.0",
     "tsmatchers": "5.0.2",
-    "tsx": "4.19.2",
+    "tsx": "4.19.3",
     "typescript": "5.7.3",
     "xml2js": "0.6.2",
     "yaml": "2.7.0"
@@ -98,6 +98,7 @@
     "lwm2m"
   ],
   "peerDependencies": {
-    "@sinclair/typebox": "^0.34.24"
+    "@aws-sdk/client-timestream-write": "^3.750.0",
+    "@sinclair/typebox": "^0.34.25"
   }
 }

package/senml/SenMLSchema.spec.ts

@@ -1,7 +1,7 @@
-import { describe, it } from 'node:test'
-import { SenML, type SenMLType } from './SenMLSchema.js'
 import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
 import { validate } from '../validate.js'
+import { SenML, type SenMLType } from './SenMLSchema.js'
 
 void describe('SenMLType', () => {
 	void it('it should validate a SenML payload', () => {

package/senml/hasValue.spec.ts

@@ -1,5 +1,5 @@
-import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
 import { hasValue } from './hasValue.js'
 
 void describe('hasValue() should determine whether an object has a value', () => {

package/senml/index.ts

@@ -1,4 +1,4 @@
+export * from './fromCBOR.js'
+export * from './lwm2mToSenML.js'
 export * from './SenMLSchema.js'
 export * from './senMLtoLwM2M.js'
-export * from './lwm2mToSenML.js'
-export * from './fromCBOR.js'

package/senml/lwm2mToSenML.spec.ts

@@ -1,13 +1,13 @@
-import { it, describe } from 'node:test'
-import type { SenMLType } from './SenMLSchema.js'
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { LwM2MObjectID } from '../lwm2m/LwM2MObjectID.js'
+import type { LwM2MObjectInstance } from '../lwm2m/LwM2MObjectInstance.js'
 import type {
 	Geolocation_14201,
 	SeaWaterLevel_14230,
 } from '../lwm2m/objects.js'
-import { LwM2MObjectID } from '../lwm2m/LwM2MObjectID.js'
-import assert from 'node:assert/strict'
-import type { LwM2MObjectInstance } from '../lwm2m/LwM2MObjectInstance.js'
 import { lwm2mToSenML } from './lwm2mToSenML.js'
+import type { SenMLType } from './SenMLSchema.js'
 
 void describe('lwm2mToSenML()', () => {
 	void it('should convert LwM2M to SenML', () => {

package/senml/lwm2mToSenML.ts

@@ -1,12 +1,12 @@
-import type { SenMLType } from './SenMLSchema.js'
+import { definitions } from '../lwm2m/definitions.js'
 import { instanceTs } from '../lwm2m/instanceTs.js'
+import { ResourceType, type LWM2MObjectInfo } from '../lwm2m/LWM2MObjectInfo.js'
 import type {
 	LwM2MObjectInstance,
 	LwM2MResourceValue,
 } from '../lwm2m/LwM2MObjectInstance.js'
 import { timestampResources } from '../lwm2m/timestampResources.js'
-import { definitions } from '../lwm2m/definitions.js'
-import { ResourceType, type LWM2MObjectInfo } from '../lwm2m/LWM2MObjectInfo.js'
+import type { SenMLType } from './SenMLSchema.js'
 
 /**
  * Convert LwM2M Object Instances to senML

package/senml/validateSenML.spec.ts

@@ -1,7 +1,7 @@
-import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
-import { validateSenML } from './validateSenML.js'
+import { describe, it } from 'node:test'
 import type { SenMLType } from './SenMLSchema.js'
+import { validateSenML } from './validateSenML.js'
 
 void describe('validateSenML()', () => {
 	void it('should validate', () => {