kuzzle-device-manager 0.4.8 → 0.4.9-2

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/DeviceManagerPlugin';
+export * from './lib/core-classes';
+export * from './lib/models';
+export * from './lib/types';

package/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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-classes"), exports);
+__exportStar(require("./lib/models"), exports);
+__exportStar(require("./lib/types"), exports);
+//# sourceMappingURL=index.js.map

package/lib/DeviceManagerPlugin.d.ts

@@ -0,0 +1,100 @@
+import { Plugin, PluginContext, JSONObject } from 'kuzzle';
+import { Decoder, PayloadHandler, AssetMappingsManager, DeviceMappingsManager } from './core-classes';
+export declare type DeviceManagerConfig = {
+    /**
+     * Administration index name
+     */
+    adminIndex: string;
+    /**
+     * Config collection name (in admin index)
+     */
+    configCollection: string;
+    /**
+     * Administration collections mappings (in admin index)
+     */
+    adminCollections: {
+        config: JSONObject;
+        devices: JSONObject;
+        payloads: JSONObject;
+    };
+    /**
+     * Tenants collections
+     */
+    collections: {
+        assets: JSONObject;
+        devices: JSONObject;
+        'asset-history': JSONObject;
+    };
+    /**
+     * Interval to write documents from the buffer
+     */
+    writerInterval: number;
+};
+export declare class DeviceManagerPlugin extends Plugin {
+    config: DeviceManagerConfig;
+    private defaultConfig;
+    private assetController;
+    private deviceController;
+    private engineController;
+    private payloadService;
+    private deviceManagerEngine;
+    private deviceService;
+    private migrationService;
+    private batchWriter;
+    private get sdk();
+    /**
+     * List of registered decoders.
+     * Map<model, decoder>
+     */
+    private decoders;
+    private deviceMappings;
+    private assetMappings;
+    get assets(): AssetMappingsManager;
+    get devices(): DeviceMappingsManager;
+    /**
+     * Constructor
+     */
+    constructor();
+    /**
+     * Init the plugin
+     */
+    init(config: JSONObject, context: PluginContext): Promise<void>;
+    /**
+     * Registers a new decoder for a device model.
+     *
+     * This will register a new API action:
+     *  - controller: `"device-manager/payload"`
+     *  - action: `action` property of the decoder or the device model in kebab-case
+     *
+     * If a custom payload handler is given then it will be used to process payloads
+     * instead of the PayloadService.process method.
+     *
+     * @param decoder Instantiated decoder
+     * @param options.handler Custom payload handler
+     *
+     * @returns Corresponding API action requestPayload
+     */
+    registerDecoder(decoder: Decoder, { handler }?: {
+        handler?: PayloadHandler;
+    }): {
+        controller: string;
+        action: string;
+    };
+    /**
+     * 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;
+    private generateConfigID;
+}

package/lib/DeviceManagerPlugin.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 models_1 = require("./models");
+class DeviceManagerPlugin extends kuzzle_1.Plugin {
+    /**
+     * Constructor
+     */
+    constructor() {
+        super({
+            kuzzleVersion: '>=2.14.0 <3'
+        });
+        /**
+         * List of registered decoders.
+         * Map<model, decoder>
+         */
+        this.decoders = new Map();
+        this.deviceMappings = new core_classes_1.DeviceMappingsManager(models_1.devicesMappings);
+        this.assetMappings = new core_classes_1.AssetMappingsManager(models_1.assetsMappings, this.deviceMappings);
+        this.api = {
+            'device-manager/payload': {
+                actions: {}
+            }
+        };
+        this.defaultConfig = {
+            adminIndex: 'device-manager',
+            configCollection: 'config',
+            adminCollections: {
+                config: {
+                    dynamic: 'strict',
+                    properties: {
+                        type: { type: 'keyword' },
+                        engine: {
+                            properties: {
+                                index: { type: 'keyword' },
+                                group: { type: 'keyword' },
+                            }
+                        },
+                        catalog: models_1.catalogMappings,
+                        'device-manager': {
+                            properties: {
+                                autoProvisionning: { type: 'boolean' },
+                            }
+                        }
+                    }
+                },
+                devices: models_1.devicesMappings,
+                payloads: {
+                    dynamic: 'strict',
+                    properties: {
+                        uuid: { type: 'keyword' },
+                        valid: { type: 'boolean' },
+                        deviceModel: { type: 'keyword' },
+                        payload: {
+                            dynamic: 'false',
+                            properties: {}
+                        }
+                    }
+                }
+            },
+            collections: {
+                assets: models_1.assetsMappings,
+                devices: models_1.devicesMappings,
+                'asset-history': models_1.assetsHistoryMappings,
+            },
+            writerInterval: 50
+        };
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    get assets() {
+        return this.assetMappings;
+    }
+    get devices() {
+        return this.deviceMappings;
+    }
+    /**
+     * Init the plugin
+     */
+    async init(config, context) {
+        this.config = lodash_1.default.merge({}, this.defaultConfig, config);
+        this.context = context;
+        this.batchWriter = new core_classes_1.BatchWriter(this.sdk, { interval: this.config.writerInterval });
+        this.batchWriter.begin();
+        this.payloadService = new core_classes_1.PayloadService(this, this.batchWriter);
+        this.deviceService = new core_classes_1.DeviceService(this, this.decoders);
+        this.migrationService = new core_classes_1.MigrationService('device-manager', this);
+        this.deviceManagerEngine = new core_classes_1.DeviceManagerEngine(this, this.assetMappings, this.deviceMappings);
+        this.assetController = new controllers_1.AssetController(this);
+        this.deviceController = new controllers_1.DeviceController(this, this.deviceService);
+        this.engineController = new kuzzle_plugin_commons_1.EngineController('device-manager', this, this.deviceManagerEngine);
+        this.api['device-manager/asset'] = this.assetController.definition;
+        this.api['device-manager/device'] = this.deviceController.definition;
+        this.pipes = {
+            'device-manager/device:beforeUpdate': this.pipeCheckEngine.bind(this),
+            'device-manager/device:beforeSearch': this.pipeCheckEngine.bind(this),
+            'device-manager/device:beforeAttachTenant': this.pipeCheckEngine.bind(this),
+            'device-manager/asset:before*': this.pipeCheckEngine.bind(this),
+            'document:beforeCreate': this.generateConfigID.bind(this),
+        };
+        await this.initDatabase();
+        await this.migrationService.run();
+        for (const decoder of this.decoders.values()) {
+            this.context.log.info(`Register API action "device-manager/payload:${decoder.action}" with decoder "${decoder.constructor.name}" for device "${decoder.deviceModel}"`);
+        }
+    }
+    /**
+     * Registers a new decoder for a device model.
+     *
+     * This will register a new API action:
+     *  - controller: `"device-manager/payload"`
+     *  - action: `action` property of the decoder or the device model in kebab-case
+     *
+     * If a custom payload handler is given then it will be used to process payloads
+     * instead of the PayloadService.process method.
+     *
+     * @param decoder Instantiated decoder
+     * @param options.handler Custom payload handler
+     *
+     * @returns Corresponding API action requestPayload
+     */
+    registerDecoder(decoder, { handler } = {}) {
+        decoder.action = decoder.action || kuzzle_1.Inflector.kebabCase(decoder.deviceModel);
+        if (this.api['device-manager/payload'].actions[decoder.action]) {
+            throw new kuzzle_1.PluginImplementationError(`A decoder for "${decoder.deviceModel}" has already been registered.`);
+        }
+        this.api['device-manager/payload'].actions[decoder.action] = {
+            handler: request => handler ? handler(request, decoder) : this.payloadService.process(request, decoder),
+            http: decoder.http,
+        };
+        this.decoders.set(decoder.deviceModel, decoder);
+        return {
+            controller: 'device-manager/payload',
+            action: decoder.action,
+        };
+    }
+    /**
+     * Initialize the administration index of the plugin
+     */
+    async initDatabase() {
+        const mutex = new kuzzle_1.Mutex('device-manager/initDatabase');
+        await mutex.lock();
+        try {
+            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
+                try {
+                    await this.sdk.index.create(this.config.adminIndex);
+                }
+                catch (error) {
+                    if (error.id !== 'services.storage.index_already_exists') {
+                        throw error;
+                    }
+                }
+            }
+            await Promise.all([
+                this.sdk.collection.create(this.config.adminIndex, this.config.configCollection, this.config.adminCollections.config),
+                this.sdk.collection.create(this.config.adminIndex, 'devices', this.deviceMappings.get()),
+                this.sdk.collection.create(this.config.adminIndex, 'payloads', this.getPayloadsMappings()),
+            ]);
+            await this.initializeConfig();
+        }
+        catch (error) {
+            // When nodes are starting at the same time, the index cache synchronization
+            // message is received too late so index.exists returns false
+            if (error.id !== 'services.storage.index_already_exists') {
+                throw error;
+            }
+        }
+        finally {
+            await mutex.unlock();
+        }
+    }
+    /**
+     * Merge custom mappings defined in the Decoder into the "payloads" collection
+     * mappings.
+     *
+     * Those custom mappings allow to search raw payloads more efficiently.
+     */
+    getPayloadsMappings() {
+        const mappings = JSON.parse(JSON.stringify(this.config.adminCollections.payloads));
+        for (const decoder of this.decoders.values()) {
+            mappings.properties.payload.properties = {
+                ...mappings.properties.payload.properties,
+                ...decoder.payloadsMappings
+            };
+        }
+        return mappings;
+    }
+    /**
+     * Initialize the config document if it does not exists
+     */
+    async initializeConfig() {
+        const exists = await this.sdk.document.exists(this.config.adminIndex, this.config.configCollection, 'plugin--device-manager');
+        if (!exists) {
+            await this.sdk.document.create(this.config.adminIndex, this.config.configCollection, {
+                type: 'device-manager',
+                'device-manager': { autoProvisionning: true }
+            }, 'plugin--device-manager');
+        }
+    }
+    async pipeCheckEngine(request) {
+        const index = request.getIndex();
+        const { result: { exists } } = await this.sdk.query({
+            controller: 'device-manager/engine',
+            action: 'exists',
+            index,
+        });
+        if (!exists) {
+            throw new kuzzle_1.BadRequestError(`Tenant "${index}" does not have a device-manager engine`);
+        }
+        return request;
+    }
+    async generateConfigID(request) {
+        if (request.getCollection() !== this.config.configCollection) {
+            return request;
+        }
+        const document = request.getBody();
+        if (document.type !== 'catalog' || request.getId(({ ifMissing: 'ignore' }))) {
+            return request;
+        }
+        request.input.args._id = `catalog--${document.catalog.deviceId}`;
+        return request;
+    }
+}
+exports.DeviceManagerPlugin = DeviceManagerPlugin;
+//# sourceMappingURL=DeviceManagerPlugin.js.map

package/lib/controllers/AssetController.d.ts

@@ -0,0 +1,7 @@
+import { KuzzleRequest, EmbeddedSDK, Plugin } from 'kuzzle';
+import { CRUDController } from './CRUDController';
+export declare class AssetController extends CRUDController {
+    get sdk(): EmbeddedSDK;
+    constructor(plugin: Plugin);
+    create(request: KuzzleRequest): Promise<import("kuzzle").Document>;
+}

package/lib/controllers/AssetController.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetController = void 0;
+const CRUDController_1 = require("./CRUDController");
+const BaseAsset_1 = require("../models/BaseAsset");
+class AssetController extends CRUDController_1.CRUDController {
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    constructor(plugin) {
+        super(plugin, 'assets');
+        this.definition = {
+            actions: {
+                create: {
+                    handler: this.create.bind(this),
+                    http: [{ verb: 'post', path: 'device-manager/:index/assets' }],
+                },
+                update: {
+                    handler: this.update.bind(this),
+                    http: [{ verb: 'put', path: 'device-manager/:index/assets/:_id' }],
+                },
+                delete: {
+                    handler: this.delete.bind(this),
+                    http: [{ verb: 'delete', path: 'device-manager/:index/assets/:_id' }],
+                },
+                search: {
+                    handler: this.search.bind(this),
+                    http: [
+                        { verb: 'post', path: 'device-manager/:index/assets/_search' },
+                        { verb: 'get', path: 'device-manager/:index/assets/_search' },
+                    ],
+                },
+            },
+        };
+    }
+    async create(request) {
+        const type = request.getBodyString('type');
+        const model = request.getBodyString('model');
+        const reference = request.getBodyString('reference');
+        if (!request.input.resource._id) {
+            const assetContent = {
+                type,
+                model,
+                reference,
+            };
+            const asset = new BaseAsset_1.BaseAsset(assetContent);
+            request.input.resource._id = asset._id;
+        }
+        return await super.create(request);
+    }
+}
+exports.AssetController = AssetController;
+//# sourceMappingURL=AssetController.js.map

package/lib/controllers/CRUDController.d.ts

@@ -0,0 +1,34 @@
+import { KuzzleRequest, PluginContext, ControllerDefinition, Plugin } from 'kuzzle';
+import { DeviceManagerConfig } from '../DeviceManagerPlugin';
+export declare class CRUDController {
+    protected context: PluginContext;
+    protected config: DeviceManagerConfig;
+    private collection;
+    definition: ControllerDefinition;
+    constructor(plugin: Plugin, collection: string);
+    get as(): (user: any) => import("kuzzle").EmbeddedSDK;
+    /**
+     * Create an asset or a device depending on the collection.
+     *
+     * @param request
+     */
+    create(request: KuzzleRequest): Promise<import("kuzzle").Document>;
+    /**
+     * Delete an asset or a device depending on the collection.
+     *
+     * @param request
+     */
+    delete(request: KuzzleRequest): Promise<number>;
+    /**
+     * search assets or devices depending on the collection.
+     *
+     * @param request
+     */
+    search(request: KuzzleRequest): Promise<any>;
+    /**
+     * Create an asset or a device depending on the collection.
+     *
+     * @param request
+     */
+    update(request: KuzzleRequest): Promise<import("kuzzle").Document>;
+}

package/lib/controllers/CRUDController.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRUDController = void 0;
+class CRUDController {
+    constructor(plugin, collection) {
+        this.config = plugin.config;
+        this.context = plugin.context;
+        this.collection = collection;
+    }
+    get as() {
+        return user => this.context.accessors.sdk.as(user, { checkRights: true });
+    }
+    /**
+     * Create an asset or a device depending on the collection.
+     *
+     * @param request
+     */
+    async create(request) {
+        const index = request.getIndex();
+        const asset = request.getBody();
+        const id = request.input.resource._id;
+        return this.as(request.context.user).document.create(index, this.collection, asset, id, { ...request.input.args });
+    }
+    /**
+     * Delete an asset or a device depending on the collection.
+     *
+     * @param request
+     */
+    async delete(request) {
+        const index = request.getIndex();
+        const id = request.getId();
+        return this.as(request.context.user).document.delete(index, this.collection, id, { ...request.input.args });
+    }
+    /**
+     * search assets or devices depending on the collection.
+     *
+     * @param request
+     */
+    async search(request) {
+        const index = request.getIndex();
+        const { searchBody } = request.getSearchParams();
+        const res = await this.as(request.context.user).query({
+            controller: 'document',
+            action: 'search',
+            index,
+            collection: this.collection,
+            body: searchBody,
+            ...request.input.args
+        });
+        return res.result;
+    }
+    /**
+     * Create an asset or a device depending on the collection.
+     *
+     * @param request
+     */
+    async update(request) {
+        const index = request.getIndex();
+        const body = request.getBody();
+        const id = request.getId();
+        return this.as(request.context.user).document.update(index, this.collection, id, body, { ...request.input.args });
+    }
+}
+exports.CRUDController = CRUDController;
+//# sourceMappingURL=CRUDController.js.map

package/lib/controllers/DeviceController.d.ts

@@ -0,0 +1,56 @@
+import { KuzzleRequest, EmbeddedSDK, Plugin } from 'kuzzle';
+import { CRUDController } from './CRUDController';
+import { DeviceService } from '../core-classes';
+export declare class DeviceController extends CRUDController {
+    private deviceService;
+    get sdk(): EmbeddedSDK;
+    constructor(plugin: Plugin, deviceService: DeviceService);
+    /**
+     * Attach a device to a tenant
+     */
+    attachTenant(request: KuzzleRequest): Promise<void>;
+    /**
+     * Attach multiple devices to multiple tenants
+     */
+    mAttach(request: KuzzleRequest): Promise<import("../types").DeviceMAttachementContent>;
+    /**
+     * Unattach a device from it's tenant
+     */
+    detach(request: KuzzleRequest): Promise<void>;
+    /**
+     * Detach multiple devices from multiple tenants
+     */
+    mDetach(request: KuzzleRequest): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    /**
+     * Link a device to an asset.
+     * @todo there is not restriction according to tenant index?
+     */
+    linkAsset(request: KuzzleRequest): Promise<void>;
+    /**
+     * Link multiple devices to multiple assets.
+     */
+    mLink(request: KuzzleRequest): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    /**
+     * Unlink a device from an asset.
+     */
+    unlink(request: KuzzleRequest): Promise<void>;
+    /**
+     * Unlink multiple device from multiple assets.
+     */
+    mUnlink(request: KuzzleRequest): Promise<{
+        errors: any[];
+        successes: any[];
+    }>;
+    /**
+     * Clean payload collection for a time period
+     */
+    prunePayloads(request: KuzzleRequest): Promise<any>;
+    private mGetDevice;
+    private mParseRequest;
+}