kuzzle-device-manager 2.0.0-rc22 → 2.0.0-rc26

package/index.d.ts

@@ -1,5 +1,7 @@
 export * from './lib/DeviceManagerPlugin';
-export * from './lib/core-classes';
-export * from './lib/models';
-export * from './lib/measures';
-export * from './lib/types';
+export * from './lib/modules/asset';
+export * from './lib/modules/asset-category';
+export * from './lib/modules/device';
+export * from './lib/modules/engine';
+export * from './lib/modules/measure';
+export * from './lib/modules/metadata';

package/index.js

@@ -15,8 +15,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib/DeviceManagerPlugin"), exports);
-__exportStar(require("./lib/core-classes"), exports);
-__exportStar(require("./lib/models"), exports);
-__exportStar(require("./lib/measures"), exports);
-__exportStar(require("./lib/types"), exports);
+__exportStar(require("./lib/modules/asset"), exports);
+__exportStar(require("./lib/modules/asset-category"), exports);
+__exportStar(require("./lib/modules/device"), exports);
+__exportStar(require("./lib/modules/engine"), exports);
+__exportStar(require("./lib/modules/measure"), exports);
+__exportStar(require("./lib/modules/metadata"), exports);
 //# sourceMappingURL=index.js.map

package/lib/DeviceManagerPlugin.d.ts

@@ -1,6 +1,8 @@
-import { Plugin, PluginContext, JSONObject, KuzzleRequest } from 'kuzzle';
-import { AssetsRegister, DevicesRegister, MeasuresRegister, DecodersRegister } from './core-classes';
-import { DeviceManagerConfiguration } from './types';
+import { Plugin, PluginContext, JSONObject, KuzzleRequest } from "kuzzle";
+import { DevicesRegister } from "./modules/device";
+import { AssetsRegister } from "./modules/asset";
+import { DeviceManagerConfiguration } from "./modules/engine";
+import { MeasuresRegister, DecodersRegister } from "./modules/measure";
 export declare class DeviceManagerPlugin extends Plugin {
     config: DeviceManagerConfiguration;
     private assetController;

package/lib/DeviceManagerPlugin.js

@@ -7,69 +7,67 @@ exports.DeviceManagerPlugin = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const kuzzle_1 = require("kuzzle");
 const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
-const controllers_1 = require("./controllers");
-const core_classes_1 = require("./core-classes");
-const measures_1 = require("./measures");
-const mappings_1 = require("./mappings");
-const AssetCategoryController_1 = require("./controllers/AssetCategoryController");
-const MetadataController_1 = require("./controllers/MetadataController");
-const AssetCategoryService_1 = require("./core-classes/AssetCategoryService");
-const MeasureService_1 = require("./core-classes/MeasureService");
+const asset_category_1 = require("./modules/asset-category");
+const metadata_1 = require("./modules/metadata");
+const device_1 = require("./modules/device");
+const asset_1 = require("./modules/asset");
+const engine_1 = require("./modules/engine");
+const measure_1 = require("./modules/measure");
 class DeviceManagerPlugin extends kuzzle_1.Plugin {
     constructor() {
         super({
-            kuzzleVersion: '>=2.16.8 <3'
+            kuzzleVersion: ">=2.16.8 <3",
         });
         this.api = {
-            'device-manager/payload': {
-                actions: {}
-            }
+            "device-manager/payload": {
+                actions: {},
+            },
         };
         /* eslint-disable sort-keys */
         this.config = {
-            adminIndex: 'device-manager',
+            adminIndex: "device-manager",
             adminCollections: {
                 config: {
-                    name: 'config',
+                    name: "config",
                     mappings: {
-                        dynamic: 'strict',
-                        properties: {}
+                        dynamic: "strict",
+                        properties: {},
                     },
                     settings: {},
                 },
                 devices: {
-                    name: 'devices',
-                    mappings: mappings_1.devicesMappings,
+                    name: "devices",
+                    mappings: device_1.devicesMappings,
                     settings: {},
                 },
                 payloads: {
-                    name: 'payloads',
-                    mappings: mappings_1.payloadsMappings,
+                    name: "payloads",
+                    mappings: measure_1.payloadsMappings,
                     settings: {},
-                }
+                },
             },
             engineCollections: {
                 config: {
-                    name: 'config',
+                    name: "config",
                     mappings: {
-                        dynamic: 'strict',
-                        properties: {}
+                        dynamic: "strict",
+                        properties: {},
                     },
-                    settings: {}
-                }
+                    settings: {},
+                },
             },
-            batchInterval: 10
+            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);
-        this.measures.register('humidity', measures_1.humidityMeasure);
-        this.measures.register('battery', measures_1.batteryMeasure);
+        this.measuresRegister = new measure_1.MeasuresRegister();
+        this.decodersRegister = new measure_1.DecodersRegister(this.measuresRegister);
+        this.devicesRegister = new device_1.DevicesRegister(this.measuresRegister);
+        this.assetsRegister = new asset_1.AssetsRegister(this.measuresRegister);
+        this.measures.register("temperature", measure_1.temperatureMeasure);
+        this.measures.register("position", measure_1.positionMeasure);
+        this.measures.register("movement", measure_1.movementMeasure);
+        this.measures.register("humidity", measure_1.humidityMeasure);
+        this.measures.register("battery", measure_1.batteryMeasure);
     }
     get sdk() {
         return this.context.accessors.sdk;
@@ -110,12 +108,12 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
     }
     async unknowPayload(request) {
         const body = request.getBody();
-        const device = request.getString('device');
+        const device = request.getString("device");
         const documentContent = {
             deviceModel: device,
-            rawPayload: body
+            rawPayload: body,
         };
-        this.sdk.document.create(this.config.adminIndex, 'payloads', documentContent);
+        this.sdk.document.create(this.config.adminIndex, "payloads", documentContent);
     }
     /**
      * Init the plugin
@@ -123,66 +121,94 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
     async init(config, context) {
         this.config = lodash_1.default.merge({}, this.config, config);
         this.context = context;
+        this.assetCategoryService = new asset_category_1.AssetCategoryService(this);
         /* eslint-disable sort-keys */
         this.pipes = {
-            'device-manager/asset:before*': this.pipeCheckEngine.bind(this),
-            'device-manager/device:beforeAttachEngine': this.pipeCheckEngine.bind(this),
-            'device-manager/device:beforeSearch': this.pipeCheckEngine.bind(this),
-            'device-manager/device:beforeUpdate': this.pipeCheckEngine.bind(this),
-            'generic:document:beforeWrite': [],
+            "device-manager/asset:before*": this.pipeCheckEngine.bind(this),
+            "device-manager/device:beforeAttachEngine": this.pipeCheckEngine.bind(this),
+            "device-manager/device:beforeSearch": this.pipeCheckEngine.bind(this),
+            "device-manager/device:beforeUpdate": this.pipeCheckEngine.bind(this),
+            "generic:document:beforeWrite": [],
+            "generic:document:afterGet": async (documents, request) => {
+                if ((request.input.args.collection === "assets" ||
+                    request.input.args.collection === "devices") &&
+                    request.input.args.options?.prettify) {
+                    for (const document of documents) {
+                        if (document._source?.metadata) {
+                            document._source.metadata =
+                                this.assetCategoryService.formatMetadataForGet(document._source.metadata);
+                        }
+                    }
+                }
+                return documents;
+            },
+            "generic:document:beforeUpdate": async (documents, request) => {
+                if ((request.input.args.collection === "assets" ||
+                    request.input.args.collection === "devices") &&
+                    request.input.args.options?.prettify) {
+                    for (const document of documents) {
+                        if (document._source?.metadata) {
+                            document._source.metadata =
+                                this.assetCategoryService.formatMetadataForES(document._source.metadata);
+                        }
+                    }
+                }
+                return documents;
+            },
         };
         /* eslint-enable sort-keys */
         this.adminConfigManager = new kuzzle_plugin_commons_1.ConfigManager(this, {
             mappings: this.config.adminCollections.config.mappings,
             settings: this.config.adminCollections.config.settings,
         });
-        this.adminConfigManager.register('device-manager', {
+        this.adminConfigManager.register("device-manager", {
             properties: {
-                provisioningStrategy: { type: 'keyword' },
-            }
+                provisioningStrategy: { type: "keyword" },
+            },
         });
-        this.adminConfigManager.register('engine', {
+        this.adminConfigManager.register("engine", {
             properties: {
-                group: { type: 'keyword' },
-                index: { type: 'keyword' },
-                name: { type: 'keyword' },
-            }
+                group: { type: "keyword" },
+                index: { type: "keyword" },
+                name: { type: "keyword" },
+            },
         });
         this.engineConfigManager = new kuzzle_plugin_commons_1.ConfigManager(this, {
             mappings: this.config.engineCollections.config.mappings,
             settings: this.config.engineCollections.config.settings,
         });
-        this.assetCategoryService = new AssetCategoryService_1.AssetCategoryService(this);
         this.batchController = new kuzzle_1.BatchController(this.sdk, {
-            interval: this.config.batchInterval
+            interval: this.config.batchInterval,
         });
-        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.measuresService);
-        this.deviceManagerEngine = new core_classes_1.DeviceManagerEngine(this, this.assetsRegister, this.devicesRegister, this.measuresRegister, this.adminConfigManager, this.engineConfigManager);
+        this.assetService = new asset_1.AssetService(this, this.batchController);
+        this.deviceService = new device_1.DeviceService(this, this.batchController, this.assetService, this.decodersRegister);
+        this.measuresService = new measure_1.MeasureService(this, this.batchController, this.assetService, this.measuresRegister, this.assetCategoryService);
+        this.payloadService = new measure_1.PayloadService(this, this.batchController, this.measuresService);
+        this.deviceManagerEngine = new engine_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.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/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 = {
+        this.assetController = new asset_1.AssetController(this, this.assetService, this.deviceService, this.assetCategoryService, this.measuresService);
+        this.deviceController = new device_1.DeviceController(this, this.deviceService, this.assetCategoryService);
+        this.decodersController = new measure_1.DecoderController(this, this.decodersRegister);
+        this.engineController = new kuzzle_plugin_commons_1.EngineController("device-manager", this, this.deviceManagerEngine);
+        this.assetCategoryController = new asset_category_1.AssetCategoryController(this, this.assetCategoryService);
+        this.metadataController = new metadata_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/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 = {
             handler: this.unknowPayload.bind(this),
-            http: [{ path: 'device-manager/payload/:device', verb: 'post' }]
+            http: [{ path: "device-manager/payload/:device", verb: "post" }],
         };
         this.hooks = {
-            'kuzzle:state:live': async () => {
+            "kuzzle:state:live": async () => {
                 await this.decodersRegister.createDefaultRights();
-                this.context.log.info('Default rights for payload controller has been registered.');
-            }
+                this.context.log.info("Default rights for payload controller has been registered.");
+            },
         };
         this.decodersRegister.printDecoders();
         await this.initDatabase();
@@ -191,10 +217,10 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
      * Initialize the administration index of the plugin
      */
     async initDatabase() {
-        const mutex = new kuzzle_1.Mutex('device-manager/initDatabase');
+        const mutex = new kuzzle_1.Mutex("device-manager/initDatabase");
         await mutex.lock();
         try {
-            if (!await this.sdk.index.exists(this.config.adminIndex)) {
+            if (!(await this.sdk.index.exists(this.config.adminIndex))) {
                 // Possible race condition because of index cache propagation.
                 // The index has been created but the node didn't receive the index
                 // cache update message yet, causing index:exists to returns false
@@ -202,22 +228,25 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
                     await this.sdk.index.create(this.config.adminIndex);
                 }
                 catch (error) {
-                    if (!error.message.includes('already exists')) {
+                    if (!error.message.includes("already exists")) {
                         throw error;
                     }
                 }
             }
             await Promise.all([
-                this.adminConfigManager.createCollection(this.config.adminIndex)
-                    .catch(error => {
+                this.adminConfigManager
+                    .createCollection(this.config.adminIndex)
+                    .catch((error) => {
                     throw new kuzzle_1.PluginImplementationError(`Cannot create admin "config" collection: ${error}`);
                 }),
-                this.sdk.collection.create(this.config.adminIndex, 'devices', this.devicesRegister.getMappings())
-                    .catch(error => {
+                this.sdk.collection
+                    .create(this.config.adminIndex, "devices", this.devicesRegister.getMappings())
+                    .catch((error) => {
                     throw new kuzzle_1.PluginImplementationError(`Cannot create admin "devices" collection: ${error}`);
                 }),
-                this.sdk.collection.create(this.config.adminIndex, 'payloads', this.getPayloadsMappings())
-                    .catch(error => {
+                this.sdk.collection
+                    .create(this.config.adminIndex, "payloads", this.getPayloadsMappings())
+                    .catch((error) => {
                     throw new kuzzle_1.PluginImplementationError(`Cannot create admin "payloads" collection: ${error}`);
                 }),
             ]);
@@ -238,7 +267,7 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
         for (const decoder of this.decodersRegister.decoders) {
             mappings.properties.payload.properties = {
                 ...mappings.properties.payload.properties,
-                ...decoder.payloadsMappings
+                ...decoder.payloadsMappings,
             };
         }
         return mappings;
@@ -247,20 +276,20 @@ class DeviceManagerPlugin extends kuzzle_1.Plugin {
      * Initialize the config document if it does not exists
      */
     async initializeConfig() {
-        const exists = await this.sdk.document.exists(this.config.adminIndex, this.adminConfigManager.collection, 'plugin--device-manager');
+        const exists = await this.sdk.document.exists(this.config.adminIndex, this.adminConfigManager.collection, "plugin--device-manager");
         if (!exists) {
             await this.sdk.document.create(this.config.adminIndex, this.adminConfigManager.collection, {
-                'device-manager': { provisioningStrategy: 'auto' },
-                type: 'device-manager'
-            }, 'plugin--device-manager');
+                "device-manager": { provisioningStrategy: "auto" },
+                type: "device-manager",
+            }, "plugin--device-manager");
         }
     }
     async pipeCheckEngine(request) {
-        const engineId = request.getString('engineId');
+        const engineId = request.getString("engineId");
         if (engineId !== this.config.adminIndex) {
-            const { result: { exists } } = await this.sdk.query({
-                action: 'exists',
-                controller: 'device-manager/engine',
+            const { result: { exists }, } = await this.sdk.query({
+                action: "exists",
+                controller: "device-manager/engine",
                 index: engineId,
             });
             if (!exists) {

package/lib/{controllers → modules/asset}/AssetController.d.ts

@@ -1,10 +1,11 @@
-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';
+import { KuzzleRequest, Plugin } from "kuzzle";
+import { MeasureService } from "../measure";
+import { AssetCategoryService } from "../asset-category";
+import { DeviceService } from "../device";
+import { RelationalController } from "../metadata";
+import { BaseAsset } from "./BaseAsset";
+import { AssetService } from "./AssetService";
+import { BaseAssetContent } from "./types/BaseAssetContent";
 export declare class AssetController extends RelationalController {
     private assetService;
     private deviceService;
@@ -22,7 +23,7 @@ export declare class AssetController extends RelationalController {
         asset: BaseAsset;
     }>;
     getMeasures(request: KuzzleRequest): Promise<{
-        measures: import("kuzzle").KDocument<import("../types").MeasureContent<import("kuzzle").JSONObject>>[];
+        measures: import("kuzzle").KDocument<import("../measure").MeasureContent<import("kuzzle").JSONObject>>[];
     }>;
     get(request: KuzzleRequest): Promise<BaseAssetContent>;
     unlinkCategory(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
@@ -35,7 +36,7 @@ export declare class AssetController extends RelationalController {
         asset: import("kuzzle").JSONObject | (() => import("kuzzle").JSONObject);
         engineId: string;
         invalids: import("kuzzle").JSONObject[];
-        valids: any[] | import("../types").MeasureContent<import("kuzzle").JSONObject>[];
+        valids: any[] | import("../measure").MeasureContent<import("kuzzle").JSONObject>[];
     }>;
     update(request: KuzzleRequest): Promise<import("kuzzle").KDocument<{
         [x: string]: any;