kuzzle-device-manager 2.0.0-rc27 → 2.0.0-rc29

package/index.d.ts

@@ -1,7 +1,7 @@
-export * from './lib/DeviceManagerPlugin';
+export * from './lib/core/DeviceManagerPlugin';
+export * from './lib/core/DeviceManagerConfiguration';
 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';
+export * from './lib/modules/decoder';
+export * from './lib/modules/shared';

package/index.js

@@ -14,11 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/DeviceManagerPlugin"), exports);
+__exportStar(require("./lib/core/DeviceManagerPlugin"), exports);
+__exportStar(require("./lib/core/DeviceManagerConfiguration"), 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);
+__exportStar(require("./lib/modules/decoder"), exports);
+__exportStar(require("./lib/modules/shared"), exports);
 //# sourceMappingURL=index.js.map

package/lib/{modules/engine/types → core}/DeviceManagerConfiguration.d.ts

@@ -1,5 +1,20 @@
 import { JSONObject } from "kuzzle";
 export declare type DeviceManagerConfiguration = {
+    /**
+     * Ignore errors at startup such as wrong mappings update.
+     *
+     * Useful to start the plugin even if the mappings are not up to date.
+     */
+    ignoreStartupErrors: boolean;
+    engine: {
+        /**
+         * Auto update collection mappings with models
+         *
+         * This can lead to huge pressure on the database at start if a lot
+         * of engine are present.
+         */
+        autoUpdate: true;
+    };
     /**
      * Administration index name
      */
@@ -31,10 +46,4 @@ export declare type DeviceManagerConfiguration = {
             settings: JSONObject;
         };
     };
-    /**
-     * Interval to write documents from the buffer
-     *
-     * @see https://docs.kuzzle.io/sdk/js/7/essentials/batch-processing/
-     */
-    batchInterval: number;
 };

package/lib/core/DeviceManagerEngine.d.ts

@@ -0,0 +1,31 @@
+import { Backend, Plugin } from "kuzzle";
+import { AbstractEngine, ConfigManager } from "kuzzle-plugin-commons";
+import { DeviceManagerConfiguration } from "./DeviceManagerConfiguration";
+import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
+import { InternalCollection } from "./InternalCollection";
+export declare type AskEngineUpdateAll = {
+    name: "ask:device-manager:engine:updateAll";
+    payload: void;
+    result: void;
+};
+export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
+    config: DeviceManagerConfiguration;
+    get app(): Backend;
+    constructor(plugin: Plugin, adminConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    updateEngines(): Promise<void>;
+    onCreate(index: string, group?: string): Promise<{
+        collections: string[];
+    }>;
+    onUpdate(index: string, group?: string): Promise<{
+        collections: any[];
+    }>;
+    onDelete(index: string): Promise<{
+        collections: string[];
+    }>;
+    createAssetsCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    private getDigitalTwinMappings;
+    createDevicesCollection(engineId: string): Promise<InternalCollection>;
+    createMeasuresCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    private getMeasuresMappings;
+    private getModels;
+}

package/lib/core/DeviceManagerEngine.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceManagerEngine = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const kuzzle_1 = require("kuzzle");
+const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
+const asset_1 = require("../modules/asset");
+const measure_1 = require("../modules/measure");
+const device_1 = require("../modules/device");
+const ask_1 = require("../modules/shared/utils/ask");
+const InternalCollection_1 = require("./InternalCollection");
+const digitalTwinMappings = {
+    asset: asset_1.assetsMappings,
+    device: device_1.devicesMappings,
+};
+class DeviceManagerEngine extends kuzzle_plugin_commons_1.AbstractEngine {
+    constructor(plugin, adminConfigManager, engineConfigManager) {
+        super("device-manager", plugin, plugin.config.adminIndex, adminConfigManager, engineConfigManager);
+        this.context = plugin.context;
+        (0, ask_1.onAsk)("ask:device-manager:engine:updateAll", async () => {
+            await this.updateEngines();
+            await this.createDevicesCollection(this.config.adminIndex);
+        });
+    }
+    get app() {
+        return global.app;
+    }
+    async updateEngines() {
+        const result = await this.sdk.document.search(this.config.adminIndex, InternalCollection_1.InternalCollection.CONFIG, {
+            query: {
+                equals: { type: "engine-device-manager" },
+            },
+        }, { lang: "koncorde", size: 1000 });
+        this.context.log.info(`Update ${result.fetched} existing engines`);
+        for (const engine of result.hits) {
+            await this.onUpdate(engine._source.engine.index, engine._source.engine.group);
+        }
+    }
+    async onCreate(index, group = "commons") {
+        const promises = [];
+        promises.push(this.createAssetsCollection(index, group));
+        promises.push(this.createDevicesCollection(index));
+        promises.push(this.createMeasuresCollection(index, group));
+        promises.push(this.engineConfigManager.createCollection(index));
+        await Promise.all(promises);
+        return {
+            collections: [
+                "assets",
+                this.engineConfigManager.collection,
+                "devices",
+                "measures",
+            ],
+        };
+    }
+    async onUpdate(index, group = "commons") {
+        const promises = [];
+        promises.push(this.createAssetsCollection(index, group));
+        promises.push(this.createDevicesCollection(index));
+        promises.push(this.createMeasuresCollection(index, group));
+        const collections = await Promise.all(promises);
+        return { collections };
+    }
+    async onDelete(index) {
+        const promises = [];
+        promises.push(this.sdk.collection.delete(index, "assets"));
+        promises.push(this.sdk.collection.delete(index, "devices"));
+        promises.push(this.sdk.collection.delete(index, "measures"));
+        await Promise.all(promises);
+        return { collections: ["assets", "devices", "measures"] };
+    }
+    async createAssetsCollection(engineId, engineGroup) {
+        const mappings = await this.getDigitalTwinMappings("asset", engineGroup);
+        await this.sdk.collection.create(engineId, InternalCollection_1.InternalCollection.ASSETS, mappings);
+        return InternalCollection_1.InternalCollection.ASSETS;
+    }
+    async getDigitalTwinMappings(digitalTwinType, engineGroup) {
+        const models = await this.getModels(this.config.adminIndex, digitalTwinType, engineGroup);
+        const measureModels = await this.getModels(this.config.adminIndex, "measure");
+        const mappings = JSON.parse(JSON.stringify(digitalTwinMappings[digitalTwinType]));
+        for (const model of models) {
+            lodash_1.default.merge(mappings.properties.metadata.properties, model._source[digitalTwinType].metadataMappings);
+            for (const [measureName, measureType] of Object.entries(model._source[digitalTwinType].measures)) {
+                const measureModel = measureModels.find((m) => m._source.measure.type === measureType);
+                if (!measureModel) {
+                    throw new kuzzle_1.InternalError(`Cannot find measure "${measureType}" declared in ${[
+                        digitalTwinType,
+                    ]} "${model._source[digitalTwinType].model}"`);
+                }
+                mappings.properties.measures.properties[measureName] = {
+                    properties: {
+                        measuredAt: { type: "date" },
+                        name: { type: "keyword" },
+                        payloadUuids: { type: "keyword" },
+                        type: { type: "keyword" },
+                        values: {
+                            properties: measureModel._source.measure.valuesMappings,
+                        },
+                    },
+                };
+            }
+        }
+        return mappings;
+    }
+    async createDevicesCollection(engineId) {
+        const mappings = await this.getDigitalTwinMappings("device");
+        await this.sdk.collection.create(engineId, InternalCollection_1.InternalCollection.DEVICES, mappings);
+        return InternalCollection_1.InternalCollection.DEVICES;
+    }
+    async createMeasuresCollection(engineId, engineGroup) {
+        const mappings = await this.getMeasuresMappings(engineGroup);
+        await this.sdk.collection.create(engineId, InternalCollection_1.InternalCollection.MEASURES, mappings);
+        return InternalCollection_1.InternalCollection.MEASURES;
+    }
+    async getMeasuresMappings(engineGroup) {
+        const models = await this.getModels(this.config.adminIndex, "measure");
+        const mappings = JSON.parse(JSON.stringify(measure_1.measuresMappings));
+        for (const model of models) {
+            lodash_1.default.merge(mappings.properties.values.properties, model._source.measure.valuesMappings);
+        }
+        const _assetsMappings = await this.getDigitalTwinMappings("asset", engineGroup);
+        mappings.properties.asset.properties.metadata.properties =
+            _assetsMappings.properties.metadata.properties;
+        return mappings;
+    }
+    async getModels(engineId, type, engineGroup) {
+        const query = {
+            and: [{ equals: { type } }],
+        };
+        if (engineGroup) {
+            query.and.push({
+                or: [
+                    { equals: { engineGroup } },
+                    { equals: { engineGroup: "commons" } },
+                ],
+            });
+        }
+        const result = await this.sdk.document.search(engineId, InternalCollection_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 100 });
+        return result.hits;
+    }
+}
+exports.DeviceManagerEngine = DeviceManagerEngine;
+//# sourceMappingURL=DeviceManagerEngine.js.map

package/lib/core/DeviceManagerPlugin.d.ts

@@ -0,0 +1,114 @@
+import { Plugin, PluginContext, JSONObject } from "kuzzle";
+import { MeasureDefinition } from "../modules/measure";
+import { AssetModelDefinition, DeviceModelDefinition } from "../modules/model";
+import { DeviceManagerConfiguration } from "./DeviceManagerConfiguration";
+export declare class DeviceManagerPlugin extends Plugin {
+    config: DeviceManagerConfiguration;
+    roles: {};
+    private deviceManagerEngine;
+    private adminConfigManager;
+    private engineConfigManager;
+    private engineController;
+    private assetModule;
+    private deviceModule;
+    private decoderModule;
+    private measureModule;
+    private modelModule;
+    private modelsRegister;
+    private decodersRegister;
+    private get sdk();
+    get models(): {
+        /**
+         * Register an asset model
+         *
+         * @param engineGroup Engine group name
+         * @param model Name of the asset model
+         * @param definition.measuresNames Array describing measures names and types
+         * @param definition.metadataMappings Metadata mappings definition
+         * @param definition.defaultMetadata Default metadata values
+         *
+         * @example
+         * ```
+         * deviceManager.models.registerAsset(
+         *   "logistic",
+         *   "container",
+         *   {
+         *     measuresNames: [
+         *       { name: "temperatureExt", type: "temperature" },
+         *       { name: "temperatureInt", type: "temperature" },
+         *       { name: "position", type: "position" },
+         *     ],
+         *     metadataMappings: {
+         *       weight: { type: "integer" },
+         *       height: { type: "integer" },
+         *     },
+         *     defaultMetadata: {
+         *       height: 20
+         *     }
+         *   }
+         * );
+         * ```
+         */
+        registerAsset: (engineGroup: string, model: string, definition: AssetModelDefinition) => void;
+        /**
+         * Register a device model
+         *
+         * @param model Name of the device model
+         * @param definition.decoded Decoder used to decode payloads
+         * @param definition.metadataMappings Metadata mappings definition
+         * @param definition.defaultMetadata Default metadata values
+         *
+         * @example
+         * ```
+         * deviceManager.models.registerDevice(
+         *   "Abeeway",
+         *   {
+         *     decoder: new DummyTempPositionDecoder(),
+         *     metadataMappings: {
+         *       serial: { type: "keyword" },
+         *     }
+         *   }
+         * );
+         * ```
+         */
+        registerDevice: (model: string, definition: DeviceModelDefinition) => void;
+        /**
+         * Register a new measure
+         *
+         * @param name Name of the measure
+         * @param valuesMappings Mappings for the measure values
+         *
+         * @example
+         * ```
+         * deviceManager.models.registerMeasure("acceleration", {
+         *   x: { type: "float" },
+         *   y: { type: "float" },
+         *   z: { type: "float" },
+         * });
+         * ```
+         */
+        registerMeasure: (name: string, measureDefinition: MeasureDefinition) => void;
+    };
+    constructor();
+    /**
+     * Init the plugin
+     */
+    init(config: JSONObject, context: PluginContext): Promise<void>;
+    private createDefaultRoles;
+    /**
+     * Initialize the administration index of the plugin
+     */
+    private initDatabase;
+    /**
+     * Merge custom mappings defined in the Decoder into the "payloads" collection
+     * mappings.
+     *
+     * Those custom mappings allow to search raw payloads more efficiently.
+     */
+    private getPayloadsMappings;
+    /**
+     * Initialize the config document if it does not exists
+     */
+    private initializeConfig;
+    private pipeCheckEngine;
+}