kuzzle-device-manager 2.0.0-rc21 → 2.0.0-rc23

package/lib/DeviceManagerPlugin.js

@@ -20,10 +20,6 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
         super({
             kuzzleVersion: '>=2.16.8 <3'
         });
-        this.decodersRegister = new core_classes_1.DecodersRegister();
-        this.measuresRegister = new core_classes_1.MeasuresRegister();
-        this.devicesRegister = new core_classes_1.DevicesRegister(this.measuresRegister);
-        this.assetsRegister = new core_classes_1.AssetsRegister(this.measuresRegister);
         this.api = {
             'device-manager/payload': {
                 actions: {}
@@ -65,6 +61,10 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
             batchInterval: 10
         };
         /* eslint-enable sort-keys */
+        this.measuresRegister = new core_classes_1.MeasuresRegister();
+        this.decodersRegister = new core_classes_1.DecodersRegister(this.measuresRegister);
+        this.devicesRegister = new core_classes_1.DevicesRegister(this.measuresRegister);
+        this.assetsRegister = new core_classes_1.AssetsRegister(this.measuresRegister);
         this.measures.register('temperature', measures_1.temperatureMeasure);
         this.measures.register('position', measures_1.positionMeasure);
         this.measures.register('movement', measures_1.movementMeasure);
@@ -159,19 +159,19 @@ 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.assetService, this.measuresRegister);
-        this.payloadService = new core_classes_1.PayloadService(this, this.batchController, this.measuresRegister, this.measuresService);
+        this.payloadService = new core_classes_1.PayloadService(this, this.batchController, 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);
         this.assetController = new controllers_1.AssetController(this, this.assetService, this.deviceService, this.assetCategoryService, this.measuresService);
         this.deviceController = new controllers_1.DeviceController(this, this.deviceService);
-        this.decodersController = new controllers_1.DecodersController(this, this.decodersRegister);
+        this.decodersController = new controllers_1.DecoderController(this, this.decodersRegister);
         this.engineController = new kuzzle_plugin_commons_1.EngineController('device-manager', this, this.deviceManagerEngine);
         this.assetCategoryController = new AssetCategoryController_1.AssetCategoryController(this, this.assetCategoryService);
         this.metadataController = new MetadataController_1.MetadataController(this, this.assetCategoryService);
         this.api['device-manager/payload'] = this.decodersRegister.getPayloadController(this.payloadService);
         this.api['device-manager/asset'] = this.assetController.definition;
         this.api['device-manager/device'] = this.deviceController.definition;
-        this.api['device-manager/decoders'] = this.decodersController.definition;
+        this.api['device-manager/decoder'] = this.decodersController.definition;
         this.api['device-manager/assetCategory'] = this.assetCategoryController.definition;
         this.api['device-manager/metadata'] = this.metadataController.definition;
         this.api['device-manager/payload'].actions.generic = {

package/lib/controllers/AssetController.d.ts

@@ -1,8 +1,9 @@
-import { JSONObject, KuzzleRequest, Plugin } from 'kuzzle';
+import { KuzzleRequest, Plugin } from 'kuzzle';
 import { BaseAsset } from '../models/BaseAsset';
 import { AssetService, DeviceService } from '../core-classes';
 import { AssetCategoryService } from '../core-classes/AssetCategoryService';
 import { RelationalController } from './RelationalController';
+import { BaseAssetContent } from '../types';
 import { MeasureService } from 'lib/core-classes/MeasureService';
 export declare class AssetController extends RelationalController {
     private assetService;
@@ -21,9 +22,9 @@ export declare class AssetController extends RelationalController {
         asset: BaseAsset;
     }>;
     getMeasures(request: KuzzleRequest): Promise<{
-        measures: import("kuzzle").KDocument<import("../types").MeasureContent>[];
+        measures: import("kuzzle").KDocument<import("../types").MeasureContent<import("kuzzle").JSONObject>>[];
     }>;
-    get(request: KuzzleRequest): Promise<JSONObject>;
+    get(request: KuzzleRequest): Promise<BaseAssetContent>;
     unlinkCategory(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
         [x: string]: any;
     }>>;
@@ -31,10 +32,10 @@ export declare class AssetController extends RelationalController {
         [x: string]: any;
     }>>;
     pushMeasures(request: KuzzleRequest): Promise<{
-        asset: JSONObject | (() => JSONObject);
+        asset: import("kuzzle").JSONObject | (() => import("kuzzle").JSONObject);
         engineId: string;
-        invalids: JSONObject[];
-        valids: any[] | import("../types").MeasureContent[];
+        invalids: import("kuzzle").JSONObject[];
+        valids: any[] | import("../types").MeasureContent<import("kuzzle").JSONObject>[];
     }>;
     update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
         [x: string]: any;
@@ -47,4 +48,10 @@ export declare class AssetController extends RelationalController {
         successes: any[];
     }>;
     delete(request: KuzzleRequest): Promise<string>;
+    /**
+     * search assets or devices depending on the collection.
+     *
+     * @param request
+     */
+    search(request: KuzzleRequest): Promise<import("kuzzle").SearchResult<import("kuzzle").KHit<BaseAssetContent>>>;
 }

package/lib/controllers/AssetController.js

@@ -113,12 +113,8 @@ class AssetController extends RelationalController_1.RelationalController {
         const engineId = request.getString('engineId');
         const category = this.getFieldPath(request, 'category', null, 'asset-category');
         const document = await this.genericGet(engineId, this.collection, id, [category]);
-        const metadata = document._source.metadata;
-        const asset = document._source;
-        if (metadata) {
-            asset.metadata = await this.assetCategoryService.formatMetadataForGet(metadata);
-        }
-        return asset;
+        this.assetCategoryService.formatDocumentMetadata(document);
+        return document._source;
     }
     async unlinkCategory(request) {
         const id = request.getId();
@@ -233,15 +229,34 @@ class AssetController extends RelationalController_1.RelationalController {
         const assetId = request.getId();
         const refresh = request.getRefresh();
         const strict = request.getBoolean('strict');
-        const devicesLinks = await this.assetService.getAsset(engineId, assetId);
-        if (Array.isArray(devicesLinks._source.deviceLinks)) {
-            for (const deviceLink of devicesLinks._source.deviceLinks) {
-                // TODO : Refacto to only get the asset one time
-                await this.deviceService.unlinkAsset(deviceLink.deviceId, { refresh, strict });
-            }
+        const asset = await this.assetService.get(engineId, assetId);
+        for (const deviceLink of asset._source.deviceLinks) {
+            // TODO : Refacto to only get the asset one time
+            await this.deviceService.unlinkAsset(deviceLink.deviceId, { refresh, strict });
         }
         return super.delete(request);
     }
+    /**
+     * search assets or devices depending on the collection.
+     *
+     * @param request
+     */
+    async search(request) {
+        const engineId = request.getString('engineId');
+        const { searchBody, from, size, scrollTTL: scroll } = request.getSearchParams();
+        const category = this.getFieldPath(request, 'category', null, 'asset-category');
+        const res = await this.sdk.document.search(engineId, this.collection, searchBody, {
+            from,
+            lang: request.getLangParam(),
+            scroll,
+            size,
+        });
+        for (const hit of res.hits) {
+            const document = await this.esDocumentToFormatted(engineId, this.collection, hit, [category]);
+            this.assetCategoryService.formatDocumentMetadata(document);
+        }
+        return res;
+    }
 }
 exports.AssetController = AssetController;
 //# sourceMappingURL=AssetController.js.map

package/lib/controllers/{DecodersController.d.ts → DecoderController.d.ts}

@@ -1,7 +1,7 @@
 import { ControllerDefinition } from 'kuzzle';
 import { DeviceManagerPlugin } from '../DeviceManagerPlugin';
 import { DecodersRegister } from '../core-classes';
-export declare class DecodersController {
+export declare class DecoderController {
     private context;
     private config;
     private decodersRegister;

package/lib/controllers/{DecodersController.js → DecoderController.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DecodersController = void 0;
-class DecodersController {
+exports.DecoderController = void 0;
+class DecoderController {
     constructor(plugin, decodersRegister) {
         this.context = plugin.context;
         this.config = plugin.config;
@@ -23,5 +23,5 @@ class DecodersController {
         return { decoders };
     }
 }
-exports.DecodersController = DecodersController;
-//# sourceMappingURL=DecodersController.js.map
+exports.DecoderController = DecoderController;
+//# sourceMappingURL=DecoderController.js.map

package/lib/controllers/DeviceController.d.ts

@@ -12,9 +12,11 @@ export declare class DeviceController extends CRUDController {
      * Create and provision a new device
      */
     create(request: KuzzleRequest): Promise<Device>;
-    update(): Promise<any>;
-    search(): Promise<void>;
-    delete(): Promise<any>;
+    update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
+        [x: string]: any;
+    }>>;
+    search(request: KuzzleRequest): Promise<any>;
+    delete(request: KuzzleRequest): Promise<string>;
     /**
      * Attach a device to a tenant
      */

package/lib/controllers/DeviceController.js

@@ -61,6 +61,18 @@ class DeviceController extends kuzzle_plugin_commons_1.CRUDController {
                     handler: this.create.bind(this),
                     http: [{ path: 'device-manager/:engineId/devices', verb: 'post' }]
                 },
+                update: {
+                    handler: this.update.bind(this),
+                    http: [{ path: 'device-manager/:engineId/device/:deviceId', verb: 'post' }]
+                },
+                search: {
+                    handler: this.search.bind(this),
+                    http: [{ path: 'device-manager/:engineId/devices/_search', verb: 'post' }]
+                },
+                delete: {
+                    handler: this.delete.bind(this),
+                    http: [{ path: 'device-manager/:engineId/device/:deviceId', verb: 'delete' }]
+                },
             }
         };
         /* eslint-enable sort-keys */
@@ -102,17 +114,17 @@ class DeviceController extends kuzzle_plugin_commons_1.CRUDController {
         });
         return device;
     }
-    // @todo to be implemented
-    async update() {
-        throw new kuzzle_1.PluginImplementationError('Not available');
+    async update(request) {
+        request.input.args.index = request.getString('engineId');
+        return super.update(request);
     }
-    // @todo to be implemented
-    async search() {
-        throw new kuzzle_1.PluginImplementationError('Not available');
+    async search(request) {
+        request.input.args.index = request.getString('engineId');
+        return super.search(request);
     }
-    // @todo to be implemented
-    async delete() {
-        throw new kuzzle_1.PluginImplementationError('Not available');
+    async delete(request) {
+        request.input.args.index = request.getString('engineId');
+        return super.delete(request);
     }
     /**
      * Attach a device to a tenant

package/lib/controllers/RelationalController.d.ts

@@ -144,6 +144,13 @@ export declare abstract class RelationalController extends CRUDController {
       * @param nestedFields : contain field name in the document to get, collection name and index name of documents that are linked
      */
     protected genericGet<TKDocumentContent extends KDocumentContent>(index: string, collection: string, documentId: string, nestedFields?: FieldPath[]): Promise<KDocument<TKDocumentContent>>;
+    /**
+     * @param index
+     * @param collection
+     * @param documentId
+     * @param nestedFields : contain field name in the document to get, collection name and index name of documents that are linked
+     */
+    protected esDocumentToFormatted<TKDocumentContent extends KDocumentContent>(index: string, collection: string, document: KDocument<TKDocumentContent>, nestedFields?: FieldPath[]): Promise<KDocument<TKDocumentContent>>;
     /**
      * Edit the document : replace content of field given by nestedField with content pointed
      * @param document : document to edit

package/lib/controllers/RelationalController.js

@@ -370,6 +370,15 @@ class RelationalController extends kuzzle_plugin_commons_1.CRUDController {
      */
     async genericGet(index, collection, documentId, nestedFields = []) {
         const document = await this.sdk.document.get(index, collection, documentId);
+        return this.esDocumentToFormatted(index, collection, document, nestedFields);
+    }
+    /**
+     * @param index
+     * @param collection
+     * @param documentId
+     * @param nestedFields : contain field name in the document to get, collection name and index name of documents that are linked
+     */
+    async esDocumentToFormatted(index, collection, document, nestedFields = []) {
         const promises = [];
         for (const nestedField of nestedFields) {
             promises.push(this.replaceNestedFieldByContent(document, nestedField));

package/lib/controllers/index.d.ts

@@ -1,3 +1,3 @@
 export * from './AssetController';
 export * from './DeviceController';
-export * from './DecodersController';
+export * from './DecoderController';

package/lib/controllers/index.js

@@ -16,5 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./AssetController"), exports);
 __exportStar(require("./DeviceController"), exports);
-__exportStar(require("./DecodersController"), exports);
+__exportStar(require("./DecoderController"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -1,6 +1,7 @@
 import { MetadataContent } from '../types/MetadataContent';
 import { AssetCategoryContent, FormattedMetadata, FormattedValue } from '../types/AssetCategoryContent';
-import { JSONObject, Plugin } from 'kuzzle';
+import { JSONObject, KDocument, Plugin } from 'kuzzle';
+import { BaseAssetContent } from '../types';
 export declare class AssetCategoryService {
     private config;
     private context;
@@ -15,6 +16,11 @@ export declare class AssetCategoryService {
     getMetadataValue(metadataValues: FormattedMetadata[], name: string): FormattedMetadata;
     formatValue(value: any): FormattedValue;
     formatMetadataForES(assetMetadata: JSONObject): FormattedMetadata[];
+    /**
+     * edit the document to format metadata
+     * @param document
+     */
+    formatDocumentMetadata(document: KDocument<BaseAssetContent>): KDocument<BaseAssetContent>;
     formatMetadataForGet(assetMetadata: FormattedMetadata[]): JSONObject;
     getValue(value: FormattedValue, format?: boolean): string | number | boolean | JSONObject;
 }

package/lib/core-classes/AssetCategoryService.js

@@ -148,6 +148,18 @@ class AssetCategoryService {
         }
         return formattedMetadata;
     }
+    /**
+     * edit the document to format metadata
+     * @param document
+     */
+    formatDocumentMetadata(document) {
+        const metadata = document._source.metadata;
+        if (metadata) {
+            const asset = document._source;
+            asset.metadata = this.formatMetadataForGet(metadata);
+        }
+        return document;
+    }
     formatMetadataForGet(assetMetadata) {
         const formattedMetadata = {};
         for (const metadata of assetMetadata) {

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

@@ -28,7 +28,7 @@ export declare class AssetService {
         errors: any[];
         successes: any[];
     }>;
-    getAsset(engineId: string, assetId: string): Promise<BaseAsset>;
+    get(engineId: string, assetId: string): Promise<BaseAsset>;
     removeMeasures(engineId: string, assetId: string, assetMeasureNames: string[], { strict }: {
         strict?: boolean;
     }): Promise<{

package/lib/core-classes/AssetService.js

@@ -28,7 +28,7 @@ class AssetService {
      * @param options.endAt Returns measures until this date (ISO8601)
      */
     async measureHistory(engineId, assetId, { size = 25, startAt, endAt }) {
-        await this.getAsset(engineId, assetId);
+        await this.get(engineId, assetId);
         const query = {
             range: {
                 measuredAt: {
@@ -68,12 +68,12 @@ class AssetService {
         });
         return results;
     }
-    async getAsset(engineId, assetId) {
+    async get(engineId, assetId) {
         const document = await this.sdk.document.get(engineId, InternalCollection_1.InternalCollection.ASSETS, assetId);
         return new BaseAsset_1.BaseAsset(document._source, document._id);
     }
     async removeMeasures(engineId, assetId, assetMeasureNames, { strict }) {
-        const asset = await this.getAsset(engineId, assetId);
+        const asset = await this.get(engineId, assetId);
         const result = asset.removeMeasures(assetMeasureNames);
         if (strict && result.notFound.length) {
             throw new kuzzle_1.NotFoundError(`AssetMeasureNames "${result.notFound}" in asset "${assetId}" of engine "${engineId}"`);

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

@@ -1,11 +1,13 @@
 import { HttpRoute, JSONObject, KuzzleRequest } from 'kuzzle';
 import { DecodedPayload } from '../types/DecodedPayload';
 import { DecoderContent } from '../types';
-import { MeasuresRegister } from './registers/MeasuresRegister';
 /**
- * Record<deviceMeasureName, type>
+ * Array of measures declaration
  */
-export declare type DecoderMeasures = Record<string, string>;
+export declare type DecoderMeasures<T = string> = ReadonlyArray<{
+    name: T;
+    type: string;
+}>;
 /**
  * Base class to implement a decoder for a device model.
  * The device model must be passed to the parent constructor.
@@ -14,13 +16,24 @@ export declare type DecoderMeasures = Record<string, string>;
 export declare abstract class Decoder {
     private _http?;
     /**
-     * Device model name
+     * Device model name.
+     *
+     * Will be infered from the class name if not defined:
+     * `AbeewayGPSDecoder` => `AbeewayGPS`
      */
     deviceModel: string;
     /**
-     * Array of device measure and their type
+     * Declaration of the measures decoded by this decoder.
+     * The name correspond of the measure name for the device.
+     * Measures types should be registered on the plugin beforehand.
+     *
+     * @example
+     *
+     * this.measures = [
+     *   { type: 'temperature', name: 'temperatureExterior' },
+     * ];
      */
-    decoderMeasures: DecoderMeasures;
+    measures: DecoderMeasures;
     /**
      * Custom name for the associated API action in the "payload" controller
      */
@@ -31,6 +44,7 @@ export declare abstract class Decoder {
      * the device model unique identifier field.
      *
      * @example
+     *
      * this.payloadsMappings = {
      *   device_properties: {
      *     properties: {
@@ -47,14 +61,8 @@ export declare abstract class Decoder {
      */
     set http(http: HttpRoute[]);
     get http(): HttpRoute[];
-    /**
-     * @param deviceModel Device model for this decoder
-     * @param decoderMeasures Measures created by this decoder
-     *
-     * @example
-     * super('AbeewayGPS', ['position']);
-     */
-    constructor(deviceModel: string, decoderMeasures: DecoderMeasures, measuresRegister: MeasuresRegister);
+    get measureNames(): string[];
+    get measureTypes(): string[];
     /**
      * Validate the payload format before processing.
      *
@@ -79,7 +87,7 @@ export declare abstract class Decoder {
      *
      * @returns Map of `Measurements` by device reference.
      */
-    abstract decode(payload: JSONObject, request: KuzzleRequest): Promise<DecodedPayload>;
+    abstract decode(payload: JSONObject, request: KuzzleRequest): Promise<DecodedPayload<Decoder>>;
     /**
      * Checks if the provided properties are present in the payload
      *

package/lib/core-classes/Decoder.js

@@ -12,20 +12,26 @@ const lodash_1 = __importDefault(require("lodash"));
  * The abstract "decode" method must be implemented.
  */
 class Decoder {
-    /**
-     * @param deviceModel Device model for this decoder
-     * @param decoderMeasures Measures created by this decoder
-     *
-     * @example
-     * super('AbeewayGPS', ['position']);
-     */
-    constructor(deviceModel, decoderMeasures, measuresRegister) {
+    constructor() {
+        /**
+         * Declaration of the measures decoded by this decoder.
+         * The name correspond of the measure name for the device.
+         * Measures types should be registered on the plugin beforehand.
+         *
+         * @example
+         *
+         * this.measures = [
+         *   { type: 'temperature', name: 'temperatureExterior' },
+         * ];
+         */
+        this.measures = [];
         /**
          * Custom mappings for the payload collection.
          * It will be injected in the "payload" property and it should allows to index
          * the device model unique identifier field.
          *
          * @example
+         *
          * this.payloadsMappings = {
          *   device_properties: {
          *     properties: {
@@ -35,13 +41,6 @@ class Decoder {
          * }
          */
         this.payloadsMappings = {};
-        this.deviceModel = deviceModel;
-        for (const [measureName, measureType] of Object.entries(decoderMeasures)) {
-            if (!measuresRegister.has(measureType)) {
-                throw new kuzzle_1.PluginImplementationError(`Decoder "${this.constructor.name}" cannot register unknown measure type "${measureType}"`);
-            }
-        }
-        this.decoderMeasures = decoderMeasures;
     }
     /**
      * Define custom HTTP routes
@@ -57,6 +56,12 @@ class Decoder {
         }
         return this._http;
     }
+    get measureNames() {
+        return this.measures.map(({ name }) => name);
+    }
+    get measureTypes() {
+        return this.measures.map(({ type }) => type);
+    }
     /**
      * Validate the payload format before processing.
      *
@@ -91,8 +96,8 @@ class Decoder {
     }
     serialize() {
         return {
-            decoderMeasures: this.decoderMeasures,
             deviceModel: this.deviceModel,
+            measures: this.measures,
         };
     }
 }

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

@@ -71,10 +71,8 @@ export declare class DeviceService {
      * isn't specified, it will be auto generated with the
      * `deviceMeasureNames` of the associated decoder
      *
-     * @param {object} linkRequest Link request between an asset by Id and a device
      * @param linkRequest.assetId Asset id to link to
      * @param linkRequest.deviceLink The link with the device
-     * @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/DeviceService.js

@@ -45,7 +45,7 @@ class DeviceService {
         let asset;
         if (linkRequest) {
             try {
-                asset = await this.assetService.getAsset(engineId, linkRequest.assetId);
+                asset = await this.assetService.get(engineId, linkRequest.assetId);
                 device.linkToAsset(linkRequest);
                 asset.linkToDevice(linkRequest);
             }
@@ -137,10 +137,8 @@ class DeviceService {
      * isn't specified, it will be auto generated with the
      * `deviceMeasureNames` of the associated decoder
      *
-     * @param {object} linkRequest Link request between an asset by Id and a device
      * @param linkRequest.assetId Asset id to link to
      * @param linkRequest.deviceLink The link with the device
-     * @param {object} options
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
@@ -157,21 +155,16 @@ class DeviceService {
         if (device._source.assetId) {
             throw new kuzzle_1.BadRequestError(`Device "${device._id}" is already linked to an asset.`);
         }
-        const asset = await this.assetService.getAsset(deviceEngineId, assetId);
+        const asset = await this.assetService.get(deviceEngineId, assetId);
         if (!asset) {
             throw new kuzzle_1.BadRequestError(`Asset "${asset._id}" does not exist.`);
         }
         if (!deviceLink.measureNamesLinks.length) {
-            deviceLink.measureNamesLinks
-                = Object.keys(this.decodersRegister
-                    .getByDeviceModel(device._source.model)
-                    .decoderMeasures)
-                    .map((deviceMeasureName) => {
-                    return {
-                        assetMeasureName: deviceMeasureName,
-                        deviceMeasureName,
-                    };
-                });
+            const decoder = this.decodersRegister.get(device._source.model);
+            deviceLink.measureNamesLinks = decoder.measureNames.map(name => ({
+                assetMeasureName: name,
+                deviceMeasureName: name,
+            }));
         }
         device.linkToAsset({ assetId, deviceLink, engineId });
         asset.linkToDevice({ assetId, deviceLink, engineId });
@@ -205,7 +198,7 @@ class DeviceService {
         if (!device._source.assetId) {
             throw new kuzzle_1.BadRequestError(`Device "${device._id}" is not linked to an asset.`);
         }
-        const asset = await this.assetService.getAsset(engineId, device._source.assetId);
+        const asset = await this.assetService.get(engineId, device._source.assetId);
         asset.unlinkDevice(device);
         device.unlinkToAsset();
         const response = await this.app.trigger(`${eventId}:before`, { asset, device });

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

@@ -22,15 +22,16 @@ export declare class MeasureService {
      * @param deviceModel Model of the device
      * @param decodedPayloads `decodedPayload`
      * @param payloadUuids Payload Uuids that generated the measurements
-     * @param {object} options
-     * @param options.provisionDevice If true and a `decodedPayload`
-     * reference a nonexisting device, create this device
+     * @param options.provisionDevice If true and a `decodedPayload` reference a nonexisting device, create this device
      * @param options.refresh Wait for ES indexation
      */
-    processDecodedPayload(deviceModel: string, decodedPayloads: DecodedPayload, payloadUuids: string[], options: {
+    processDecodedPayload(deviceModel: string, decodedPayload: DecodedPayload, payloadUuids: string[], options: {
         refresh?: string;
     }): Promise<void>;
     private buildMeasures;
+    /**
+     * Get devices or create missing ones (when auto-provisionning is enabled)
+     */
     private getDevices;
     private provisionDevices;
     /**
@@ -59,7 +60,7 @@ export declare class MeasureService {
         asset: () => JSONObject;
         engineId: string;
         invalids: JSONObject[];
-        valids: MeasureContent[];
+        valids: MeasureContent<JSONObject>[];
     }>;
     /**
      * Register new measures in the engine