kuzzle-device-manager 2.0.0-rc8 → 2.0.0-rc9

package/lib/DeviceManagerPlugin.js

@@ -158,7 +158,7 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
         });
         this.assetService = new core_classes_1.AssetService(this, this.batchController);
         this.deviceService = new core_classes_1.DeviceService(this, this.batchController, this.assetService, this.decodersRegister);
-        this.measuresService = new MeasureService_1.MeasureService(this, this.batchController, this.deviceService, this.assetService, this.measuresRegister);
+        this.measuresService = new MeasureService_1.MeasureService(this, this.batchController, this.assetService, this.measuresRegister);
         this.payloadService = new core_classes_1.PayloadService(this, this.batchController, this.measuresRegister, this.measuresService);
         this.deviceManagerEngine = new core_classes_1.DeviceManagerEngine(this, this.assetsRegister, this.devicesRegister, this.measuresRegister, this.adminConfigManager, this.engineConfigManager);
         this.decodersRegister.init(this.context);

package/lib/core-classes/Decoder.d.ts

@@ -2,8 +2,10 @@ import { HttpRoute, JSONObject, KuzzleRequest } from 'kuzzle';
 import { DecodedPayload } from '../types/DecodedPayload';
 import { DecoderContent } from '../types';
 import { MeasuresRegister } from './registers/MeasuresRegister';
-export declare type DecoderMeasures = Record<string, // deviceMeasureName
-string>;
+/**
+ * Record<deviceMeasureName, type>
+ */
+export declare type DecoderMeasures = Record<string, string>;
 /**
  * Base class to implement a decoder for a device model.
  * The device model must be passed to the parent constructor.

package/lib/core-classes/MeasureService.d.ts

@@ -2,19 +2,16 @@ import { BatchController, JSONObject } from 'kuzzle';
 import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
 import { DecodedPayload, MeasureContent } from '../types';
 import { AssetService } from './AssetService';
-import { DeviceService } from './DeviceService';
 import { MeasuresRegister } from './registers/MeasuresRegister';
 export declare class MeasureService {
     private config;
     private context;
     private batch;
-    private deviceService;
     private assetService;
     private measuresRegister;
-    private static eventId;
     private get sdk();
     private get app();
-    constructor(plugin: DeviceManagerPlugin, batchController: BatchController, deviceService: DeviceService, assetService: AssetService, measuresRegister: MeasuresRegister);
+    constructor(plugin: DeviceManagerPlugin, batchController: BatchController, assetService: AssetService, measuresRegister: MeasuresRegister);
     /**
      * Register new measures from a device, updates :
      * - admin device
@@ -30,15 +27,12 @@ export declare class MeasureService {
      * reference a nonexisting device, create this device
      * @param options.refresh Wait for ES indexation
      */
-    registerByDecodedPayload(deviceModel: string, decodedPayloads: DecodedPayload, payloadUuids: Array<string>, { autoProvisionDevice, refresh }?: {
-        autoProvisionDevice?: boolean;
-        refresh?: 'wait_for' | 'false';
-    }): Promise<{}>;
-    /**
-     * Takes all informations to craft a Measure and insert it in
-     * caching structures
-     */
-    private insertIntoSortingRecords;
+    processDecodedPayload(deviceModel: string, decodedPayloads: DecodedPayload, payloadUuids: string[], options: {
+        refresh?: string;
+    }): Promise<void>;
+    private buildMeasures;
+    private getDevices;
+    private provisionDevices;
     /**
      * Register new measures from a device, updates :
      * - linked asset
@@ -50,7 +44,6 @@ export declare class MeasureService {
      * @param assetId Asset id
      * @param jsonMeasurements `AssetMeasurement` array from a request
      * @param kuid Kuid of the user pushing the measurements
-     * @param {object} options
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */

package/lib/core-classes/MeasureService.js

@@ -10,10 +10,9 @@ const InternalCollection_1 = require("../InternalCollection");
 const models_1 = require("../models");
 const types_1 = require("../types");
 class MeasureService {
-    constructor(plugin, batchController, deviceService, assetService, measuresRegister) {
+    constructor(plugin, batchController, assetService, measuresRegister) {
         this.config = plugin.config;
         this.context = plugin.context;
-        this.deviceService = deviceService;
         this.assetService = assetService;
         this.measuresRegister = measuresRegister;
         this.batch = batchController;
@@ -39,158 +38,100 @@ class MeasureService {
      * reference a nonexisting device, create this device
      * @param options.refresh Wait for ES indexation
      */
-    async registerByDecodedPayload(deviceModel, decodedPayloads, payloadUuids, { autoProvisionDevice, refresh } = {}) {
-        const eventId = `${MeasureService.eventId}:registerByDecodedPayload`;
-        // Create caching structures
-        const engineMeasures = {};
-        const assetMeasuresInEngine = {};
-        const deviceMeasuresInEngine = {};
-        const measurementsWithoutDevice = {};
-        const unknownTypeMeasurements = [];
-        // Craft and insert measures in cache by each device
-        // Need to be atomic (no Promise.all) because it would erase the array in `assetMeasuresInEngineCache` and `deviceMeasuresInEngineCache`
-        for (const [reference, measurements] of Object.entries(decodedPayloads)) {
-            await this.insertIntoSortingRecords(engineMeasures, assetMeasuresInEngine, deviceMeasuresInEngine, measurementsWithoutDevice, unknownTypeMeasurements, payloadUuids, deviceModel, reference, measurements, autoProvisionDevice);
-        }
-        const response = await this.app.trigger(`${eventId}:before`, {
-            assetMeasuresInEngineCache: assetMeasuresInEngine,
-            deviceMeasuresInEngineCache: deviceMeasuresInEngine,
-            engineMeasuresCache: engineMeasures,
-            unknownTypeMeasurements,
-        });
-        // Push measures in db
-        // In Engine measures
-        await Promise.all(Object.entries(response.engineMeasuresCache).map(([engineId, measures]) => {
-            const measureArray = measures;
-            return this.historizeEngineMeasures(engineId, measureArray, { refresh });
-        }));
-        // Update measures of assets and update documents
-        await Promise.all(Object.entries(response.assetMeasuresInEngineCache).map(async ([engineId, assetMeasuresRecord]) => {
-            for (const { asset, measures } of Object.values(assetMeasuresRecord)) {
-                asset.updateMeasures(measures);
-            }
-            await this.sdk.document.mUpdate(engineId, InternalCollection_1.InternalCollection.ASSETS, Object.values(assetMeasuresRecord).map(({ asset }) => ({ _id: asset._id, body: asset._source })), { refresh });
-        }));
-        // Update measures of devices and update documents
-        const devices = [];
-        await Promise.all(Object.entries(response.deviceMeasuresInEngineCache).map(async ([engineId, deviceMeasuresRecord]) => {
-            await Promise.all(Object.values(deviceMeasuresRecord).map(({ device, measures }) => {
-                device.updateMeasures(measures);
-                devices.push(device);
-            }));
-            if (engineId !== this.config.adminIndex) {
-                await this.sdk.document.mUpdate(engineId, InternalCollection_1.InternalCollection.DEVICES, Object.values(deviceMeasuresRecord).map(({ device }) => ({ _id: device._id, body: device._source })), { refresh });
-            }
-        }));
-        await this.sdk.document.mUpdate(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, devices.map(device => ({ _id: device._id, body: device._source })), { refresh });
-        await this.app.trigger(`${eventId}:after`, {
-            assetMeasuresInEngineCache: assetMeasuresInEngine,
-            deviceMeasuresInEngineCache: deviceMeasuresInEngine,
-            engineMeasuresCache: engineMeasures,
-        });
-        return {
-        // TOSEE : What to return, how (serialization) ?
-        // TOSEE : Stock updated assets, devices and measures for return result ?
-        // engineMeasuresCache,
-        // assetMeasuresInEngineCache,
-        // deviceMeasuresInEngineCache,
-        // unaivailableTypeMeasurements,
-        // measurementsWithoutDevice,
-        };
-    }
-    /**
-     * Takes all informations to craft a Measure and insert it in
-     * caching structures
-     */
-    async insertIntoSortingRecords(engineMeasuresCache, assetMeasuresInEngineCache, deviceMeasuresInEngineCache, measurementsWithoutDevice, unknownTypeMeasurements, payloadUuids, deviceModel, reference, measurements, autoProvisionDevice) {
-        // Search device in cache or get in db
-        const deviceId = models_1.Device.id(deviceModel, reference);
-        let device = null;
-        try {
-            device = await this.deviceService.getDevice(this.config, deviceId);
-        }
-        catch (error) { }
-        if (!device) {
-            if (autoProvisionDevice) {
-                // TODO : Optimize, ES request to create and then update at end
-                device = await this.deviceService.create({
-                    model: deviceModel,
-                    reference,
-                });
+    async processDecodedPayload(deviceModel, decodedPayloads, payloadUuids, options) {
+        const references = Object.keys(decodedPayloads);
+        const devices = await this.getDevices(deviceModel, references, options);
+        for (const device of devices) {
+            let asset = null;
+            if (device._source.assetId) {
+                try {
+                    const { _source, _id } = await this.batch.get(device._source.engineId, InternalCollection_1.InternalCollection.ASSETS, device._source.assetId);
+                    asset = new models_1.BaseAsset(_source, _id);
+                }
+                catch (error) {
+                    this.app.log.error(`[${device._source.engineId}] Cannot find asset "${device._source.assetId}" linked to device "${device._id}".`);
+                }
             }
-            else {
-                measurementsWithoutDevice[reference] = measurements;
-                return;
+            const measures = this.buildMeasures(device, asset, decodedPayloads[device._source.reference], payloadUuids);
+            const updatedMeasures = await this.app.trigger('device-manager:measures:receive', measures, { asset, device });
+            device.updateMeasures(updatedMeasures);
+            await this.sdk.document.update(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, device._id, { measures: device._source.measures });
+            if (device._source.engineId) {
+                await this.sdk.document.update(device._source.engineId, InternalCollection_1.InternalCollection.DEVICES, device._id, { measures: device._source.measures });
+                // @todo replace by batch.mCreate when available
+                await this.sdk.document.mCreate(device._source.engineId, InternalCollection_1.InternalCollection.MEASURES, updatedMeasures.map(measure => ({ body: measure })), { strict: true });
+                if (asset) {
+                    asset.updateMeasures(updatedMeasures);
+                    await this.sdk.document.update(device._source.engineId, InternalCollection_1.InternalCollection.ASSETS, asset._id, { measures: asset._source.measures });
+                }
             }
         }
-        const engineId = device._source.engineId ?? this.config.adminIndex;
-        const assetId = device._source.assetId;
-        const deviceMeasures = { device, measures: [] };
-        let deviceMeasuresInEngine = deviceMeasuresInEngineCache[engineId];
-        if (!deviceMeasuresInEngine) {
-            deviceMeasuresInEngine = { [deviceId]: deviceMeasures };
-            deviceMeasuresInEngineCache[engineId] = deviceMeasuresInEngine;
-        }
-        // Search asset in cache or get in db
-        let assetCacheEntity = null;
-        if (assetId) {
-            let assetMeasuresInEngine = assetMeasuresInEngineCache[engineId];
-            if (!assetMeasuresInEngine) {
-                assetMeasuresInEngine = {};
-                assetMeasuresInEngineCache[engineId] = assetMeasuresInEngine;
-            }
-            assetCacheEntity = assetMeasuresInEngine[assetId];
-            if (!assetCacheEntity) {
-                assetCacheEntity = {
-                    asset: await this.assetService.getAsset(engineId, assetId),
-                    measures: [],
-                };
-                assetMeasuresInEngine[assetId] = assetCacheEntity;
+    }
+    buildMeasures(device, asset, measurements, payloadUuids) {
+        const measures = [];
+        for (const measurement of measurements) {
+            if (!this.measuresRegister.has(measurement.type)) {
+                this.app.log.warn(`Unknown measurement "${measurement.type}" from Decoder "${device._source.model}"`);
+                continue;
             }
+            const deviceMeasureName = measurement.deviceMeasureName || measurement.type;
+            const assetMeasureName = asset === null ? undefined : this.findAssetMeasureName(device, asset, deviceMeasureName);
+            const measureContent = {
+                assetMeasureName,
+                deviceMeasureName,
+                measuredAt: measurement.measuredAt,
+                origin: {
+                    assetId: asset ? asset._id : undefined,
+                    deviceModel: device._source.model,
+                    id: device._id,
+                    payloadUuids,
+                    type: types_1.OriginType.DEVICE,
+                },
+                type: measurement.type,
+                unit: this.measuresRegister.get(measurement.type).unit,
+                values: measurement.values,
+            };
+            measures.push(measureContent);
         }
-        // Search for engine in cache or see if index exist
-        let engineMeasures = null;
-        if (engineId !== this.config.adminIndex) {
-            engineMeasures = engineMeasuresCache[engineId];
-            if (!engineMeasures) {
-                engineMeasures = [];
-                engineMeasuresCache[engineId] = engineMeasures;
-            }
+        return measures;
+    }
+    async getDevices(deviceModel, references, { refresh }) {
+        let devices = [];
+        // @todo replace with batch.mGet when available
+        const { successes, errors } = await this.sdk.document.mGet(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, references.map(reference => models_1.Device.id(deviceModel, reference)));
+        for (const { _source, _id } of successes) {
+            devices.push(new models_1.Device(_source, _id));
         }
-        for (const measurement of measurements) {
-            // Get type
-            if (!this.measuresRegister.has(measurement.type)) {
-                unknownTypeMeasurements.push(measurement);
+        // If we have unknown devices, let's check if we should register them
+        if (errors.length > 0) {
+            const { _source } = await this.batch.get(this.config.adminIndex, this.config.adminCollections.config.name, 'plugin--device-manager');
+            if (_source['device-manager'].provisioningStrategy === 'auto') {
+                const newDevices = await this.provisionDevices(deviceModel, errors, { refresh });
+                devices.push(...newDevices);
             }
             else {
-                // Refine measurements in measures
-                const deviceMeasureName = measurement.deviceMeasureName ?? measurement.type;
-                const assetMeasureName = this.findAssetMeasureName(deviceId, measurement.deviceMeasureName, assetCacheEntity);
-                const measureContent = {
-                    assetMeasureName,
-                    deviceMeasureName,
-                    measuredAt: measurement.measuredAt,
-                    origin: {
-                        assetId,
-                        deviceModel,
-                        id: deviceId,
-                        payloadUuids,
-                        type: types_1.OriginType.DEVICE,
-                    },
-                    type: measurement.type,
-                    unit: this.measuresRegister.get(measurement.type).unit,
-                    values: measurement.values,
-                };
-                // Insert measures in cache structs
-                if (engineMeasures) {
-                    engineMeasures.push(measureContent);
-                }
-                if (assetMeasureName) {
-                    assetCacheEntity.measures.push(measureContent);
-                }
-                deviceMeasures.measures.push(measureContent);
+                this.app.log.info(`Skipping new devices "${errors.join(', ')}". Auto-provisioning is disabled.`);
             }
         }
+        return devices;
+    }
+    async provisionDevices(deviceModel, deviceIds, { refresh }) {
+        const newDevices = deviceIds.map(deviceId => {
+            // Reference may contains a "-"
+            const [, ...rest] = deviceId.split('-');
+            const reference = rest.join('');
+            return {
+                _id: models_1.Device.id(deviceModel, reference),
+                body: {
+                    measures: [],
+                    model: deviceModel,
+                    reference,
+                }
+            };
+        });
+        // @todo replace with batch.mCreate when available
+        const { successes } = await this.sdk.document.mCreate(this.config.adminIndex, InternalCollection_1.InternalCollection.DEVICES, newDevices, { refresh, strict: true, });
+        return successes.map(({ _source, _id }) => new models_1.Device(_source, _id));
     }
     /**
      * Register new measures from a device, updates :
@@ -203,12 +144,10 @@ class MeasureService {
      * @param assetId Asset id
      * @param jsonMeasurements `AssetMeasurement` array from a request
      * @param kuid Kuid of the user pushing the measurements
-     * @param {object} options
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
     async registerByAsset(engineId, assetId, jsonMeasurements, kuid, { refresh, strict } = {}) {
-        const eventId = `${MeasureService.eventId}:registerByAsset`;
         const invalidMeasurements = [];
         const validMeasures = [];
         const asset = await this.assetService.getAsset(engineId, assetId);
@@ -250,20 +189,8 @@ class MeasureService {
             };
         }
         asset.updateMeasures(validMeasures);
-        const response = await this.app.trigger(`${eventId}:before`, {
-            asset,
-            engineId,
-            invalidMeasurements,
-            validMeasures,
-        });
-        await this.sdk.document.update(engineId, InternalCollection_1.InternalCollection.ASSETS, asset._id, { measures: response.asset._source.measures });
+        await this.sdk.document.update(engineId, InternalCollection_1.InternalCollection.ASSETS, asset._id, { measures: asset._source.measures });
         await this.historizeEngineMeasures(engineId, validMeasures, { refresh });
-        await this.app.trigger(`${eventId}:after`, {
-            asset,
-            engineId,
-            invalidMeasurements,
-            validMeasures,
-        });
         return {
             asset: asset.serialize,
             engineId,
@@ -284,19 +211,11 @@ class MeasureService {
             && lodash_1.default.has(toValidate, 'type')
             && this.measuresRegister.has(toValidate.type);
     }
-    findAssetMeasureName(deviceId, deviceMeasureName, assetMeasures) {
-        if (assetMeasures) {
-            const link = assetMeasures.asset._source.deviceLinks.find(deviceLink => deviceLink.deviceId === deviceId);
-            if (link) {
-                const measureNameLink = link.measureNamesLinks.find(nameLink => nameLink.deviceMeasureName === deviceMeasureName);
-                if (measureNameLink) {
-                    return measureNameLink.assetMeasureName;
-                }
-            }
-        }
-        return null;
+    findAssetMeasureName(device, asset, deviceMeasureName) {
+        const deviceLink = asset._source.deviceLinks.find(link => link.deviceId === device._id);
+        const measureLink = deviceLink.measureNamesLinks.find(nameLink => nameLink.deviceMeasureName === deviceMeasureName);
+        return measureLink.assetMeasureName;
     }
 }
 exports.MeasureService = MeasureService;
-MeasureService.eventId = 'device-manager:measure';
 //# sourceMappingURL=MeasureService.js.map

package/lib/core-classes/PayloadService.d.ts

@@ -20,5 +20,7 @@ export declare class PayloadService {
      */
     process(request: KuzzleRequest, decoder: Decoder, { refresh }?: {
         refresh?: 'wait_for' | 'false';
-    }): Promise<{}>;
+    }): Promise<void | {
+        valid: boolean;
+    }>;
 }

package/lib/core-classes/PayloadService.js

@@ -45,9 +45,7 @@ class PayloadService {
             }, uuid);
         }
         const decodedPayload = await decoder.decode(payload, request);
-        const pluginConfig = await this.batch.get(this.config.adminIndex, this.config.adminCollections.config.name, 'plugin--device-manager');
-        const autoProvisionDevice = pluginConfig._source['device-manager'].provisioningStrategy === 'auto';
-        return this.measureService.registerByDecodedPayload(decoder.deviceModel, decodedPayload, [uuid], { autoProvisionDevice, refresh });
+        return this.measureService.processDecodedPayload(decoder.deviceModel, decodedPayload, [uuid], { refresh });
     }
 }
 exports.PayloadService = PayloadService;

package/lib/models/BaseAsset.d.ts

@@ -9,7 +9,12 @@ export declare class BaseAsset {
     constructor(content: BaseAssetContent, _id?: string);
     linkToDevice(linkRequest: LinkRequest): void;
     unlinkDevice(device: Device): void;
-    updateMeasures(measures: MeasureContent[]): void;
+    /**
+     * Updates the asset measures.
+     *
+     * Only keep the latest measures
+     */
+    updateMeasures(newMeasures: MeasureContent[]): void;
     removeMeasures(assetMeasureNames: string[]): {
         notFound: string[];
         removed: any[];

package/lib/models/BaseAsset.js

@@ -21,18 +21,21 @@ class BaseAsset {
         const linkToKeep = this._source.deviceLinks.filter((deviceLink) => deviceLink.deviceId !== device._id);
         this._source.deviceLinks = linkToKeep;
     }
-    updateMeasures(measures) {
-        const measuresByName = new Map();
-        for (const existingMeasure of this._source.measures) {
-            measuresByName.set(existingMeasure.assetMeasureName, existingMeasure);
-        }
-        for (const measure of measures) {
-            const existingMeasure = measuresByName.get(measure.assetMeasureName);
-            if (!existingMeasure || existingMeasure.measuredAt < measure.measuredAt) {
-                measuresByName.set(measure.assetMeasureName, measure);
+    /**
+     * Updates the asset measures.
+     *
+     * Only keep the latest measures
+     */
+    updateMeasures(newMeasures) {
+        for (const newMeasure of newMeasures) {
+            const idx = this._source.measures.findIndex(measure => measure.assetMeasureName === newMeasure.assetMeasureName);
+            if (idx === -1) {
+                this._source.measures.push(newMeasure);
+            }
+            else if (newMeasure.measuredAt > this._source.measures[idx].measuredAt) {
+                this._source.measures[idx] = newMeasure;
             }
         }
-        this._source.measures = Array.from(measuresByName.values());
     }
     removeMeasures(assetMeasureNames) {
         const removed = [];

package/lib/models/Device.d.ts

@@ -11,5 +11,10 @@ export declare class Device {
     };
     unlinkToAsset(): void;
     linkToAsset(linkRequest: LinkRequest): void;
-    updateMeasures(measures: MeasureContent[]): void;
+    /**
+     * Updates the asset measures.
+     *
+     * Only keep the latest measures
+     */
+    updateMeasures(newMeasures: MeasureContent[]): void;
 }

package/lib/models/Device.js

@@ -27,18 +27,21 @@ class Device {
     linkToAsset(linkRequest) {
         this._source.assetId = linkRequest.assetId;
     }
-    updateMeasures(measures) {
-        const measuresByName = new Map();
-        for (const existingMeasure of this._source.measures) {
-            measuresByName.set(existingMeasure.deviceMeasureName, existingMeasure);
-        }
-        for (const measure of measures) {
-            const existingMeasure = measuresByName.get(measure.deviceMeasureName);
-            if (!existingMeasure || existingMeasure.measuredAt < measure.measuredAt) {
-                measuresByName.set(measure.deviceMeasureName, measure);
+    /**
+     * Updates the asset measures.
+     *
+     * Only keep the latest measures
+     */
+    updateMeasures(newMeasures) {
+        for (const newMeasure of newMeasures) {
+            const idx = this._source.measures.findIndex(measure => measure.deviceMeasureName === newMeasure.deviceMeasureName);
+            if (idx === -1) {
+                this._source.measures.push(newMeasure);
+            }
+            else if (newMeasure.measuredAt > this._source.measures[idx].measuredAt) {
+                this._source.measures[idx] = newMeasure;
             }
         }
-        this._source.measures = Array.from(measuresByName.values());
     }
 }
 exports.Device = Device;

package/lib/types/DecodedPayload.d.ts

@@ -1,40 +1,21 @@
 import { Measurement } from './measures/MeasureContent';
 /**
- * Result of the `Decoder.decode` method.
+ * Record containing decoded measurements for each device.
  *
- * Contains the decoded measurements.
+ * Record<deviceReference, Measurement[]>
  *
  * @example
  * const decodedPayload: DecodedPayload = {
  *   'BZH42AZF': [
  *     {
  *       deviceMeasureName: 'battery',
- *       measuredAt: Date.now(),
+ *       measuredAt: 1655379939496,
  *       type: 'battery',
  *       values: { battery: 32 },
  *     },
- *     {
- *       deviceMeasureName: 'internal_temperature',
- *       measuredAt: Date.now(),
- *       type: 'temperature',
- *       values: { temperature: -3 },
- *     },
- *     {
- *       deviceMeasureName: 'external_temperature',
- *       measuredAt: Date.now(),
- *       type: 'temperature',
- *       values: { temperature: 39 },
- *     },
  *   ],
- *
  *   'IS7L8HK': [
  *     {
- *       deviceMeasureName: 'battery',
- *       measuredAt: 1655379939496,
- *       type: 'battery',
- *       values: { battery: 92 },
- *     },
- *     {
  *       deviceMeasureName: 'internal_temperature',
  *       measuredAt: 1655379939496,
  *       type: 'temperature',
@@ -49,5 +30,4 @@ import { Measurement } from './measures/MeasureContent';
  *   ],
  * };
  */
-export declare type DecodedPayload = Record<string, // deviceReference
-Measurement[]>;
+export declare type DecodedPayload = Record<string, Measurement[]>;

package/lib/types/DecodedPayload.js

@@ -1,3 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// @todo we should have an intermediary object
 //# sourceMappingURL=DecodedPayload.js.map

package/lib/types/measures/MeasureContent.d.ts

@@ -25,6 +25,8 @@ export interface Measurement {
     measuredAt?: number;
     /**
      * Name given by the decoder to the measure.
+     *
+     * By default, it's the type of the measure
      */
     deviceMeasureName?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager",
-  "version": "2.0.0-rc8",
+  "version": "2.0.0-rc9",
   "description": "Manage your IoT devices and assets. Choose a provisioning strategy, receive and decode payload, handle your IoT business logic.",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "repository": {