kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/core-classes/registers/DecodersRegister.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecodersRegister = void 0;
+const kuzzle_1 = require("kuzzle");
+class DecodersRegister {
+    constructor() {
+        this._decoders = new Map();
+    }
+    get sdk() {
+        return this.context.accessors.sdk;
+    }
+    get decoders() {
+        return Array.from(this._decoders.values());
+    }
+    init(context) {
+        this.context = context;
+    }
+    async list() {
+        const decoders = this.decoders.map(decoder => decoder.serialize());
+        return decoders;
+    }
+    /**
+     * 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
+     *
+     * @param decoder Instantiated decoder
+     *
+     * @returns Corresponding API action requestPayload
+     */
+    register(decoder) {
+        decoder.action = decoder.action || kuzzle_1.Inflector.kebabCase(decoder.deviceModel);
+        if (this._decoders.has(decoder.deviceModel)) {
+            throw new kuzzle_1.PluginImplementationError(`Decoder for device model "${decoder.deviceModel}" already registered`);
+        }
+        this._decoders.set(decoder.deviceModel, decoder);
+        return {
+            action: decoder.action,
+            controller: 'device-manager/payload',
+        };
+    }
+    /**
+     * Build the PayloadController with registered decoders
+     *
+     * @todo generate OpenAPI specification
+     *
+     * @internal
+     */
+    getPayloadController(payloadService) {
+        const controllers = { actions: {} };
+        for (const decoder of this.decoders) {
+            controllers.actions[decoder.action] = {
+                handler: async (request) => {
+                    const source = request.getBoolean('source');
+                    const ret = await payloadService.process(request, decoder);
+                    return source ? ret : undefined;
+                },
+                http: decoder.http,
+            };
+        }
+        return controllers;
+    }
+    printDecoders() {
+        for (const decoder of this.decoders) {
+            this.context.log.info(`Decoder for "${decoder.deviceModel}" registered`);
+        }
+    }
+    /**
+     * Creates default roles, profiles and users associated to the generated actions
+     * in the Payload controller.
+     *
+     * This method never returns a rejected promise.
+     */
+    async createDefaultRights() {
+        try {
+            await this.createDefaultRoles();
+        }
+        catch (error) {
+            this.context.log.error(`Cannot register default decoders roles: ${error}${error.stack}`);
+            return;
+        }
+        try {
+            await this.createDefaultProfiles();
+        }
+        catch (error) {
+            this.context.log.error(`Cannot register default decoders profiles: ${error}${error.stack}`);
+            return;
+        }
+        try {
+            await this.createDefaultUsers();
+        }
+        catch (error) {
+            this.context.log.error(`Cannot register default decoders users: ${error}${error.stack}`);
+        }
+    }
+    async createDefaultUsers() {
+        const promises = [];
+        const gatewayUser = {
+            content: {
+                profileIds: []
+            }
+        };
+        for (const decoder of this.decoders) {
+            const userId = `payload-gateway.${decoder.action}`;
+            const user = {
+                content: {
+                    // each created user has only the profile of the same name
+                    profileIds: [userId]
+                }
+            };
+            gatewayUser.content.profileIds.push(userId);
+            promises.push(this.sdk.security.createUser(userId, user)
+                .catch(error => {
+                if (error.id !== 'security.user.already_exists') {
+                    throw error;
+                }
+                return this.sdk.security.updateUser(userId, user);
+            }));
+        }
+        promises.push(this.sdk.security.createUser('payload-gateway', gatewayUser)
+            .catch(error => {
+            if (error.id !== 'security.user.already_exists') {
+                throw error;
+            }
+            return this.sdk.security.updateUser('payload-gateway', gatewayUser);
+        }));
+        await Promise.all(promises);
+    }
+    async createDefaultProfiles() {
+        const promises = [];
+        const gatewayProfile = {
+            policies: []
+        };
+        for (const decoder of this.decoders) {
+            const profileId = `payload-gateway.${decoder.action}`;
+            const profile = {
+                // each created profile has only the role of the same name
+                policies: [{ roleId: profileId }]
+            };
+            gatewayProfile.policies.push({ roleId: profileId });
+            promises.push(this.sdk.security.createOrReplaceProfile(profileId, profile));
+        }
+        promises.push(this.sdk.security.createOrReplaceProfile('payload-gateway', gatewayProfile));
+        await Promise.all(promises);
+    }
+    async createDefaultRoles() {
+        const promises = [];
+        for (const decoder of this.decoders) {
+            const roleId = `payload-gateway.${decoder.action}`;
+            const role = {
+                controllers: {
+                    'device-manager/payload': {
+                        actions: {
+                            [decoder.action]: true
+                        }
+                    }
+                }
+            };
+            promises.push(this.sdk.security.createOrReplaceRole(roleId, role));
+        }
+        await Promise.all(promises);
+    }
+}
+exports.DecodersRegister = DecodersRegister;
+//# sourceMappingURL=DecodersRegister.js.map

package/lib/core-classes/registers/DevicesRegister.d.ts

@@ -0,0 +1,20 @@
+import { JSONObject } from 'kuzzle';
+import { MeasuresRegister } from './MeasuresRegister';
+export declare class DevicesRegister {
+    private mappings;
+    private measuresRegister;
+    constructor(measuresRegister: MeasuresRegister);
+    /**
+     * Register custom metadata for devices
+     *
+     * @param metadata Device custom metadata mappings
+     *
+     * ```js
+     * plugin.devices.registerMetadata({
+     *   serial: { type: 'keyword' },
+     * });
+     * ```
+     */
+    registerMetadata(metadata: JSONObject): void;
+    getMappings(): JSONObject;
+}

package/lib/core-classes/registers/DevicesRegister.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevicesRegister = void 0;
+const kuzzle_1 = require("kuzzle");
+const mappings_1 = require("../../mappings");
+class DevicesRegister {
+    constructor(measuresRegister) {
+        this.mappings = JSON.parse(JSON.stringify(mappings_1.devicesMappings));
+        this.measuresRegister = measuresRegister;
+    }
+    /**
+     * Register custom metadata for devices
+     *
+     * @param metadata Device custom metadata mappings
+     *
+     * ```js
+     * plugin.devices.registerMetadata({
+     *   serial: { type: 'keyword' },
+     * });
+     * ```
+     */
+    registerMetadata(metadata) {
+        for (const [name, value] of Object.entries(metadata)) {
+            if (this.mappings.properties.metadata.properties[name]) {
+                throw new kuzzle_1.PluginImplementationError(`Device metadata "${name}" already exists`);
+            }
+            this.mappings.properties.metadata.properties[name] = value;
+        }
+    }
+    getMappings() {
+        const mappings = JSON.parse(JSON.stringify(this.mappings));
+        mappings.properties.measures = this.measuresRegister.getMappings();
+        return mappings;
+    }
+}
+exports.DevicesRegister = DevicesRegister;
+//# sourceMappingURL=DevicesRegister.js.map

package/lib/core-classes/registers/MeasuresRegister.d.ts

@@ -0,0 +1,29 @@
+import { JSONObject } from 'kuzzle';
+import { MeasureDefinition } from '../../types';
+export declare class MeasuresRegister {
+    private mappings;
+    /**
+     * Registered measures
+     *
+     * Map<type, MeasureDefinition>
+     */
+    private measures;
+    constructor();
+    /**
+     * Register custom measure definition
+     *
+     * ```js
+     * plugin.measure.register('humidity', {
+     *   unit: {
+     *     name: 'Humidity',
+     *     sign: '%',
+     *     type: 'number',
+     *   },
+     *   mappings: { humidity: { type: 'float' } },
+     * });
+     * ```
+     */
+    register(type: string, measure: MeasureDefinition): void;
+    get(type: string): MeasureDefinition;
+    getMappings(): JSONObject;
+}

package/lib/core-classes/registers/MeasuresRegister.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeasuresRegister = void 0;
+const kuzzle_1 = require("kuzzle");
+const mappings_1 = require("../../mappings");
+class MeasuresRegister {
+    constructor() {
+        /**
+         * Registered measures
+         *
+         * Map<type, MeasureDefinition>
+         */
+        this.measures = new Map();
+        this.mappings = JSON.parse(JSON.stringify(mappings_1.measuresMappings));
+    }
+    /**
+     * Register custom measure definition
+     *
+     * ```js
+     * plugin.measure.register('humidity', {
+     *   unit: {
+     *     name: 'Humidity',
+     *     sign: '%',
+     *     type: 'number',
+     *   },
+     *   mappings: { humidity: { type: 'float' } },
+     * });
+     * ```
+     */
+    register(type, measure) {
+        if (this.measures.has(type)) {
+            throw new kuzzle_1.PluginImplementationError(`Measure "${type}" already exists.`);
+        }
+        for (const [field, definition] of Object.entries(measure.valuesMappings)) {
+            if (this.mappings.properties.values.properties[field]) {
+                throw new kuzzle_1.PluginImplementationError(`Field "${type}" already exists in measures mappings.`);
+            }
+            this.mappings.properties.values.properties[field] = definition;
+        }
+        this.measures.set(type, measure);
+    }
+    get(type) {
+        if (!this.measures.has(type)) {
+            throw new kuzzle_1.PluginImplementationError(`Measure "${type}" does not exists.`);
+        }
+        return this.measures.get(type);
+    }
+    getMappings() {
+        return this.mappings;
+    }
+}
+exports.MeasuresRegister = MeasuresRegister;
+//# sourceMappingURL=MeasuresRegister.js.map

package/lib/mappings/assetsMappings.d.ts

@@ -0,0 +1,36 @@
+export declare const assetsMappings: {
+    dynamic: string;
+    properties: {
+        measures: {
+            properties: {};
+        };
+        metadata: {
+            dynamic: string;
+            properties: {};
+        };
+        model: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+        reference: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+        type: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+    };
+};

package/lib/mappings/assetsMappings.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assetsMappings = void 0;
+exports.assetsMappings = {
+    dynamic: 'strict',
+    properties: {
+        measures: {
+            properties: {
+            // autogenerated from devices mappings
+            }
+        },
+        metadata: {
+            dynamic: 'false',
+            properties: {}
+        },
+        model: {
+            fields: {
+                text: { type: 'text' }
+            },
+            type: 'keyword'
+        },
+        reference: {
+            fields: {
+                text: { type: 'text' }
+            },
+            type: 'keyword'
+        },
+        type: {
+            fields: {
+                text: { type: 'text' }
+            },
+            type: 'keyword'
+        }
+    }
+};
+//# sourceMappingURL=assetsMappings.js.map

package/lib/mappings/deviceMappings.d.ts

@@ -0,0 +1,44 @@
+export declare const devicesMappings: {
+    dynamic: string;
+    properties: {
+        assetId: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+        engineId: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+        measures: {
+            properties: {};
+        };
+        metadata: {
+            dynamic: string;
+            properties: {};
+        };
+        model: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+        reference: {
+            fields: {
+                text: {
+                    type: string;
+                };
+            };
+            type: string;
+        };
+    };
+};

package/lib/mappings/deviceMappings.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devicesMappings = void 0;
+exports.devicesMappings = {
+    dynamic: 'strict',
+    properties: {
+        assetId: {
+            fields: {
+                text: { type: 'text' }
+            },
+            type: 'keyword'
+        },
+        engineId: {
+            fields: {
+                text: { type: 'text' }
+            },
+            type: 'keyword'
+        },
+        measures: {
+            properties: {
+            // measures mappings will be injected by the plugin
+            }
+        },
+        metadata: {
+            dynamic: 'false',
+            properties: {},
+        },
+        model: {
+            fields: {
+                text: { type: 'text' },
+            },
+            type: 'keyword'
+        },
+        reference: {
+            fields: {
+                text: { type: 'text' },
+            },
+            type: 'keyword'
+        }
+    }
+};
+//# sourceMappingURL=deviceMappings.js.map

package/lib/mappings/index.d.ts

@@ -0,0 +1,4 @@
+export * from './assetsMappings';
+export * from './deviceMappings';
+export * from './payloadsMappings';
+export * from './measuresMappings';

package/lib/mappings/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./assetsMappings"), exports);
+__exportStar(require("./deviceMappings"), exports);
+__exportStar(require("./payloadsMappings"), exports);
+__exportStar(require("./measuresMappings"), exports);
+//# sourceMappingURL=index.js.map

package/lib/mappings/measuresMappings.d.ts

@@ -0,0 +1,53 @@
+export declare const measuresMappings: {
+    dynamic: string;
+    properties: {
+        measuredAt: {
+            type: string;
+        };
+        /**
+         * A device may have different measures for the same type (e.g. measure temperature 2 times)
+         * Should be set when you link the device to the asset
+         */
+        name: {
+            type: string;
+        };
+        origin: {
+            type: string;
+            properties: {
+                id: {
+                    type: string;
+                };
+                model: {
+                    type: string;
+                };
+                payloadUuids: {
+                    type: string;
+                };
+                type: {
+                    type: string;
+                };
+                assetId: {
+                    type: string;
+                };
+            };
+        };
+        /**
+         * Type of the measure. (e.g. "temperature")
+         * The type name is also the name of the sub-property to look at
+         * in the "values" object to get the measure main value.
+         */
+        type: {
+            type: string;
+        };
+        /**
+         * Measure self-description
+         */
+        unit: {
+            dynamic: string;
+            properties: {};
+        };
+        values: {
+            properties: {};
+        };
+    };
+};

package/lib/mappings/measuresMappings.js

@@ -0,0 +1,48 @@
+"use strict";
+/* eslint-disable sort-keys */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measuresMappings = void 0;
+exports.measuresMappings = {
+    dynamic: 'strict',
+    properties: {
+        measuredAt: { type: 'double' },
+        /**
+         * A device may have different measures for the same type (e.g. measure temperature 2 times)
+         * Should be set when you link the device to the asset
+         */
+        name: { type: 'keyword' },
+        origin: {
+            type: 'nested',
+            properties: {
+                // ID of the device (document _id)
+                id: { type: 'keyword' },
+                // E.g. "AbeewayTemp"
+                model: { type: 'keyword' },
+                // Array of payload uuids that were used to create this measure.
+                payloadUuids: { type: 'keyword' },
+                // E.g. "device"
+                type: { type: 'keyword' },
+                // Asset linked to the device when the measure was made
+                assetId: { type: 'keyword' },
+            }
+        },
+        /**
+         * Type of the measure. (e.g. "temperature")
+         * The type name is also the name of the sub-property to look at
+         * in the "values" object to get the measure main value.
+         */
+        type: { type: 'keyword' },
+        /**
+         * Measure self-description
+         */
+        unit: {
+            dynamic: 'false',
+            properties: {}
+        },
+        values: {
+            properties: {},
+        },
+    }
+};
+/* eslint-enable sort-keys */
+//# sourceMappingURL=measuresMappings.js.map

package/lib/mappings/payloadsMappings.d.ts

@@ -0,0 +1,18 @@
+export declare const payloadsMappings: {
+    dynamic: string;
+    properties: {
+        deviceModel: {
+            type: string;
+        };
+        payload: {
+            dynamic: string;
+            properties: {};
+        };
+        uuid: {
+            type: string;
+        };
+        valid: {
+            type: string;
+        };
+    };
+};

package/lib/mappings/payloadsMappings.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payloadsMappings = void 0;
+exports.payloadsMappings = {
+    dynamic: 'strict',
+    properties: {
+        deviceModel: { type: 'keyword' },
+        payload: {
+            dynamic: 'false',
+            properties: {}
+        },
+        uuid: { type: 'keyword' },
+        valid: { type: 'boolean' },
+    }
+};
+//# sourceMappingURL=payloadsMappings.js.map

package/lib/measures/BatteryMeasure.d.ts

@@ -0,0 +1,7 @@
+import { Measurement, MeasureDefinition } from '../types';
+export interface BatteryMeasurement extends Measurement {
+    values: {
+        battery: number;
+    };
+}
+export declare const batteryMeasure: MeasureDefinition;

package/lib/measures/BatteryMeasure.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batteryMeasure = void 0;
+exports.batteryMeasure = {
+    valuesMappings: { battery: { type: 'integer' } },
+    unit: {
+        name: 'Volt',
+        sign: 'v',
+        type: 'number',
+    },
+};
+//# sourceMappingURL=BatteryMeasure.js.map

package/lib/measures/HumidityMeasure.d.ts

@@ -0,0 +1,7 @@
+import { Measurement, MeasureDefinition } from '../types';
+export interface HumidityMeasurement extends Measurement {
+    values: {
+        humidity: number;
+    };
+}
+export declare const humidityMeasure: MeasureDefinition;

package/lib/measures/HumidityMeasure.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.humidityMeasure = void 0;
+exports.humidityMeasure = {
+    valuesMappings: { humidity: { type: 'float' } },
+    unit: {
+        name: 'Humidity',
+        sign: '%',
+        type: 'number',
+    },
+};
+//# sourceMappingURL=HumidityMeasure.js.map