kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/types/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];
@@ -10,7 +14,12 @@ 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("./Measure"), exports);
-__exportStar(require("./DeviceContent"), exports);
 __exportStar(require("./BaseAssetContent"), exports);
+__exportStar(require("./DeviceContent"), exports);
+__exportStar(require("./measures/MeasureContent"), exports);
+__exportStar(require("./measures/Measurement"), exports);
+__exportStar(require("./measures/MeasureDefinition"), exports);
+__exportStar(require("./DecoderContent"), exports);
+__exportStar(require("./DecodedPayload"), exports);
+__exportStar(require("./DeviceManagerConfiguration"), exports);
 //# sourceMappingURL=index.js.map

package/lib/types/measures/MeasureContent.d.ts

@@ -0,0 +1,56 @@
+import { JSONObject } from 'kuzzle';
+import { KDocumentContent } from 'kuzzle-sdk';
+import { MeasurementUnit } from './MeasureDefinition';
+/**
+ * Represent the content of a measure document.
+ */
+export interface MeasureContent extends KDocumentContent {
+    /**
+     * 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: 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?: string;
+    /**
+     * Measurement self-description
+     */
+    unit: MeasurementUnit;
+    /**
+     * Mesured values
+     */
+    values: JSONObject;
+    /**
+     * Micro Timestamp of the measure
+     */
+    measuredAt: number;
+    /**
+     * Origin of the measure
+     */
+    origin: {
+        /**
+         * ID of the device (document _id)
+         */
+        id: string;
+        /**
+         * E.g. "device"
+         */
+        type: string;
+        /**
+         * E.g. "AbeewayTemp"
+         */
+        model: string;
+        /**
+         * Array of payload uuids that were used to create this measure.
+         */
+        payloadUuids: string[];
+        /**
+         * Asset ID linked to the device when the measure was made
+         */
+        assetId?: string;
+    };
+}

package/lib/types/measures/MeasureContent.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MeasureContent.js.map

package/lib/types/measures/MeasureDefinition.d.ts

@@ -0,0 +1,40 @@
+import { JSONObject } from 'kuzzle';
+/**
+ * Represents a measurement unit definition
+ *
+ * @example
+ * {
+     name: 'Degree',
+     sign: '°',
+     type: 'number',
+   }
+ *
+ */
+export interface MeasurementUnit {
+    name: string;
+    sign: string;
+    type: string;
+}
+/**
+ * Represents a measure definition registered by the Device Manager
+ *
+ * @example
+ * {
+ *   measurementMappings: { temperature: { type: 'float' } },
+     unit: {
+       name: 'Degree',
+       sign: '°',
+       type: 'number',
+     },
+   }
+ */
+export interface MeasureDefinition {
+    /**
+     * Unit definition
+     */
+    unit: MeasurementUnit;
+    /**
+     * Mappings for the measurement values in order to index the fields
+     */
+    valuesMappings: JSONObject;
+}

package/lib/types/measures/MeasureDefinition.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MeasureDefinition.js.map

package/lib/types/measures/Measurement.d.ts

@@ -0,0 +1,19 @@
+import { JSONObject } from 'kuzzle';
+/**
+ * Represents a measurement of a value
+ *
+ * This interface should be extended and the `values` property specialized
+ * to declare new measurement type.
+ */
+export interface Measurement {
+    /**
+     * Property containing the actual measurement.
+     *
+     * This should be specialized by child interfaces
+     */
+    values: JSONObject;
+    /**
+     * Micro Timestamp of the measurement time
+     */
+    measuredAt: number;
+}

package/lib/types/{Measure.js → measures/Measurement.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=Measure.js.map
+//# sourceMappingURL=Measurement.js.map

package/lib/utils/index.d.ts

@@ -1 +1 @@
-export * from './events';
+export * from './writeMany';

package/lib/utils/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    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];
@@ -10,5 +14,5 @@ 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("./events"), exports);
+__exportStar(require("./writeMany"), exports);
 //# sourceMappingURL=index.js.map

package/lib/utils/writeMany.d.ts

@@ -0,0 +1,13 @@
+import { JSONObject } from 'kuzzle';
+export declare type mRequest = {
+    _id: string;
+    body: JSONObject;
+};
+export declare type mResponse = {
+    successes: JSONObject[];
+    errors: JSONObject[];
+};
+export declare function writeToDatabase(documents: mRequest[], writer: (docs: mRequest[]) => Promise<mResponse>): Promise<{
+    errors: any[];
+    successes: any[];
+}>;

package/lib/utils/writeMany.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeToDatabase = void 0;
+async function writeToDatabase(documents, writer) {
+    const results = {
+        errors: [],
+        successes: [],
+    };
+    const limit = global.kuzzle.config.limits.documentsWriteCount;
+    if (documents.length <= limit) {
+        const { successes, errors } = await writer(documents);
+        results.successes.concat(successes);
+        results.errors.concat(errors);
+        return results;
+    }
+    const writeMany = async (start, end) => {
+        const devices = documents.slice(start, end);
+        const { successes, errors } = await writer(devices);
+        results.successes.concat(successes);
+        results.errors.concat(errors);
+    };
+    let offset = 0;
+    let offsetLimit = limit;
+    let done = false;
+    while (!done) {
+        await writeMany(offset, offsetLimit);
+        offset += limit;
+        offsetLimit += limit;
+        if (offsetLimit >= documents.length) {
+            done = true;
+            await writeMany(offset, documents.length);
+        }
+    }
+    return results;
+}
+exports.writeToDatabase = writeToDatabase;
+//# sourceMappingURL=writeMany.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kuzzle-device-manager",
-  "version": "0.4.13",
-  "description": "Manage your IoT devices and assets. Choose a provisionning strategy, receive and decode payload, handle your IoT business logic.",
+  "version": "2.0.0-rc3",
+  "description": "Manage your IoT devices and assets. Choose a provisioning strategy, receive and decode payload, handle your IoT business logic.",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "repository": {
     "type": "git",
@@ -25,32 +25,28 @@
   "license": "Apache-2.0",
   "dependencies": {
     "csvtojson": "~2.0.10",
-    "kuzzle-plugin-commons": "https://github.com/kuzzleio/kuzzle-plugin-commons/archive/refs/tags/0.0.1.tar.gz",
+    "json-stable-stringify": "^1.0.1",
+    "kuzzle-plugin-commons": "https://github.com/kuzzleio/kuzzle-plugin-commons/archive/refs/tags/1.0.4.tar.gz",
     "uuid": "~8.3.2"
   },
   "devDependencies": {
-    "@types/node": "^16.11.11",
-    "@typescript-eslint/eslint-plugin": "^5.5.0",
-    "@typescript-eslint/parser": "^5.5.0",
+    "@types/node": "^17.0.21",
+    "@typescript-eslint/eslint-plugin": "^5.14.0",
+    "@typescript-eslint/parser": "^5.14.0",
     "cucumber": "^6.0.5",
-    "ergol": "^1.0.1",
-    "eslint": "^8.4.0",
+    "ergol": "^1.0.2",
+    "eslint": "^8.10.0",
     "eslint-friendly-formatter": "^4.0.1",
     "eslint-loader": "^4.0.2",
-    "kuzzle": "^2.15.2",
-    "kuzzle-sdk": "^7.7.6",
+    "kuzzle": "^2.17.6",
+    "kuzzle-sdk": "^7.9.1",
     "lodash": "^4.17.21",
-    "mocha": "^9.1.3",
-    "mock-require": "^3.0.3",
-    "rewire": "^5.0.0",
     "should": "^13.2.3",
-    "should-sinon": "^0.0.6",
-    "sinon": "^12.0.1",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.5.2"
+    "ts-node": "^10.7.0",
+    "typescript": "^4.6.2"
   },
   "peerDependencies": {
-    "kuzzle": "^2.15.2"
+    "kuzzle": "^2.17.3"
   },
   "files": [
     "index.js",

package/lib/controllers/CRUDController.d.ts

@@ -1,34 +0,0 @@
-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

@@ -1,65 +0,0 @@
-"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/core-classes/BatchProcessing/BatchController.d.ts

@@ -1,34 +0,0 @@
-import { DocumentController, Kuzzle as KuzzleSDK, JSONObject } from 'kuzzle';
-import { BatchWriter } from './BatchWriter';
-/**
- * Overload of the document controller.
- *
- * This class replace the following methods and will execute them by batch using
- * m* actions:
- *  - create
- *  - replace
- *  - createOrReplace
- *  - update
- *  - get
- *  - exists
- *  - delete
- *
- * The m* actions returns the successes in the same order as in the request so
- * since we have the index of the single document inside the array of documents
- * sent to the action, we can retrieve the corresponding result in the array of
- * results.
- *
- */
-export declare class BatchController extends DocumentController {
-    writer: BatchWriter;
-    constructor(sdk: KuzzleSDK, writer: BatchWriter);
-    protected extractErrorById(id: string, errors: any[]): any;
-    protected extractErrorByContent(content: JSONObject, errors: any[]): any;
-    create(index: string, collection: string, content: JSONObject, _id?: string, options?: JSONObject): Promise<any>;
-    replace(index: string, collection: string, _id: string, content: JSONObject, options?: JSONObject): Promise<any>;
-    createOrReplace(index: string, collection: string, _id: string, content: JSONObject, options?: JSONObject): Promise<any>;
-    update(index: string, collection: string, _id: string, changes: JSONObject, options?: JSONObject): Promise<any>;
-    get(index: string, collection: string, id: string): Promise<any>;
-    exists(index: string, collection: string, id: string): Promise<any>;
-    delete(index: string, collection: string, id: string): Promise<any>;
-}

package/lib/core-classes/BatchProcessing/BatchController.js

@@ -1,115 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BatchController = void 0;
-const lodash_1 = __importDefault(require("lodash"));
-const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
-const kuzzle_1 = require("kuzzle");
-/**
- * Overload of the document controller.
- *
- * This class replace the following methods and will execute them by batch using
- * m* actions:
- *  - create
- *  - replace
- *  - createOrReplace
- *  - update
- *  - get
- *  - exists
- *  - delete
- *
- * The m* actions returns the successes in the same order as in the request so
- * since we have the index of the single document inside the array of documents
- * sent to the action, we can retrieve the corresponding result in the array of
- * results.
- *
- */
-class BatchController extends kuzzle_1.DocumentController {
-    constructor(sdk, writer) {
-        super(sdk);
-        this.writer = writer;
-    }
-    extractErrorById(id, errors) {
-        return errors.find(({ document }) => document._id === id);
-    }
-    extractErrorByContent(content, errors) {
-        return errors.find(e => {
-            const responseDoc = (0, json_stable_stringify_1.default)(lodash_1.default.omit(e.document._source, ['_kuzzle_info']));
-            const originDoc = (0, json_stable_stringify_1.default)(content);
-            return responseDoc === originDoc;
-        });
-    }
-    async create(index, collection, content, _id, options) {
-        try {
-            const { idx, promise } = this.writer.addCreate(index, collection, content, _id, options);
-            const { successes, errors } = await promise.promise;
-            if (errors.length > 0) {
-                const error = this.extractErrorByContent(content, errors);
-                if (error) {
-                    throw new kuzzle_1.BadRequestError(`Cannot create document in "${index}":"${collection}" : ${error.reason}`);
-                }
-            }
-            return successes[idx];
-        }
-        catch (exception) {
-            const error = this.extractErrorByContent(content, exception.errors);
-            if (error) {
-                throw new kuzzle_1.BadRequestError(`Cannot create document in "${index}":"${collection}" : ${error.reason}`);
-            }
-        }
-    }
-    async replace(index, collection, _id, content, options) {
-        const { idx, promise } = this.writer.addReplace(index, collection, content, _id, options);
-        const { successes, errors } = await promise.promise;
-        const error = this.extractErrorById(_id, errors);
-        if (error) {
-            throw new kuzzle_1.BadRequestError(`Cannot replace document "${index}":"${collection}":"${_id}": ${error.reason}`);
-        }
-        return successes[idx];
-    }
-    async createOrReplace(index, collection, _id, content, options) {
-        const { idx, promise } = this.writer.addCreateOrReplace(index, collection, content, _id, options);
-        const { successes, errors } = await promise.promise;
-        const error = this.extractErrorById(_id, errors);
-        if (error) {
-            throw new kuzzle_1.BadRequestError(`Cannot create or replace document "${index}":"${collection}":"${_id}": ${error.reason}`);
-        }
-        return successes[idx];
-    }
-    async update(index, collection, _id, changes, options) {
-        const { idx, promise } = this.writer.addUpdate(index, collection, changes, _id, options);
-        const { successes, errors } = await promise.promise;
-        const error = this.extractErrorById(_id, errors);
-        if (error) {
-            throw new kuzzle_1.BadRequestError(`Cannot update document "${index}":"${collection}":"${_id}": ${error.reason}`);
-        }
-        return successes[idx];
-    }
-    async get(index, collection, id) {
-        const { promise } = this.writer.addGet(index, collection, undefined, id);
-        const { successes } = await promise.promise;
-        const document = successes.find(({ _id }) => _id === id);
-        if (!document) {
-            throw new kuzzle_1.NotFoundError(`Document "${index}":"${collection}":"${id}" not found`, 'services.storage.not_found');
-        }
-        return document;
-    }
-    async exists(index, collection, id) {
-        const { idx, promise } = this.writer.addExists(index, collection, undefined, id);
-        const { successes } = await promise.promise;
-        return successes[idx];
-    }
-    async delete(index, collection, id) {
-        const { idx, promise } = this.writer.addDelete(index, collection, undefined, id);
-        const { successes, errors } = await promise.promise;
-        const error = errors.find(({ _id }) => _id === id);
-        if (error) {
-            throw new kuzzle_1.NotFoundError(`Cannot delete document "${index}":"${collection}":"${id}" : ${error.reason}`);
-        }
-        return successes[idx];
-    }
-}
-exports.BatchController = BatchController;
-//# sourceMappingURL=BatchController.js.map

package/lib/core-classes/BatchProcessing/BatchWriter.d.ts

@@ -1,110 +0,0 @@
-import { EmbeddedSDK, JSONObject } from 'kuzzle';
-import { BatchController } from './BatchController';
-import { InstrumentablePromise } from './InstrumentablePromise';
-/**
- * Map of index and collections with documents, options and associated promise
- */
-declare type IndexBuffer = {
-    [index: string]: {
-        [collection: string]: {
-            documents: Array<{
-                _id: string;
-                body: JSONObject;
-            }>;
-            promise: InstrumentablePromise;
-            options: JSONObject;
-        };
-    };
-};
-export declare class BatchBuffer {
-    indexes: IndexBuffer;
-    /**
-     * Add a document to the buffer of a specific collection
-     *
-     * @param index Index name
-     * @param collection Collection name
-     * @param body Document content
-     * @param _id Document ID
-     * @param options Option object passed to the m* action
-     *
-     * @returns An object containing the index of the array of results and a promise resolving to the array of results
-     */
-    add(index: string, collection: string, body: JSONObject, _id?: string, options?: JSONObject): {
-        idx: number;
-        promise: InstrumentablePromise;
-    };
-}
-/**
- * This class handle buffers for every supported API action of the document controller:
- *  - create, update, createOrReplace, replace, get, exists, delete
- *
- * Each buffer is filled with documents to be write/get/delete into a collection.
- *
- * A timer will regularly execute the m* actions with the documents inside the buffers.
- *
- * If the interval is too big, buffers may contain too much documents for Kuzzle limits.
- * (e.g. "limits.documentsWriteCount" is 200 by default)
- */
-export declare class BatchWriter {
-    private timer;
-    private sdk;
-    /**
-     * Timer interval to execute m* API actions
-     */
-    private interval;
-    /**
-     * Max write buffer size. (Should match "limits.documentsWriteCount")
-     */
-    private maxWriteBufferSize;
-    /**
-     * Max read buffer size. (Should match "limits.documentsReadCount")
-     */
-    private maxReadBufferSize;
-    private buffers;
-    /**
-     * Document Controller overload
-     */
-    document: BatchController;
-    get addCreate(): any;
-    get addUpdate(): any;
-    get addGet(): any;
-    get addExists(): any;
-    get addDelete(): any;
-    get addReplace(): any;
-    get addCreateOrReplace(): any;
-    /**
-     * @param sdk Connected SDK
-     * @param options.interval Timer interval in ms (50). Actions will be executed every {interval} ms
-     * @param options.maxWriteBufferSize Max write buffer size (200). (Should match "limits.documentsWriteCount")
-     * @param options.maxReadBufferSize Max read buffer size. (Should match "limits.documentsReadCount")
-     */
-    constructor(sdk: EmbeddedSDK, { interval, maxWriteBufferSize, maxReadBufferSize }?: {
-        interval?: number;
-        maxWriteBufferSize?: number;
-        maxReadBufferSize?: number;
-    });
-    /**
-     * Execute API actions with documents stored in the buffers.
-     */
-    execute(): Promise<void>;
-    /**
-     * Initialize the buffers and start the timer
-     */
-    begin(): void;
-    /**
-     * Execute pending actions from the buffers and stop the timer.
-     */
-    end(): Promise<void>;
-    /**
-     * Reset all the buffers
-     */
-    private prepareRound;
-    private sendCreateBuffer;
-    private sendUpdateBuffer;
-    private sendReplaceBuffer;
-    private sendCreateOrReplaceBuffer;
-    private sendGetBuffer;
-    private sendExistsBuffer;
-    private sendDeleteBuffer;
-}
-export {};