kuzzle-device-manager 0.4.13 → 2.0.0-rc3

package/lib/measures/MovementMeasure.d.ts

@@ -0,0 +1,7 @@
+import { Measurement, MeasureDefinition } from '../types';
+export interface MovementMeasurement extends Measurement {
+    values: {
+        movement: boolean;
+    };
+}
+export declare const movementMeasure: MeasureDefinition;

package/lib/measures/MovementMeasure.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movementMeasure = void 0;
+exports.movementMeasure = {
+    valuesMappings: { movement: { type: 'boolean' } },
+    unit: {
+        name: 'Moving',
+        sign: null,
+        type: 'boolean',
+    },
+};
+//# sourceMappingURL=MovementMeasure.js.map

package/lib/measures/PositionMeasure.d.ts

@@ -0,0 +1,12 @@
+import { Measurement, MeasureDefinition } from '../types';
+export interface PositionMeasurement extends Measurement {
+    values: {
+        position: {
+            lat: number;
+            lon: number;
+        };
+        altitude?: number;
+        accuracy?: number;
+    };
+}
+export declare const positionMeasure: MeasureDefinition;

package/lib/measures/PositionMeasure.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.positionMeasure = void 0;
+exports.positionMeasure = {
+    valuesMappings: {
+        accuracy: { type: 'float' },
+        altitude: { type: 'float' },
+        position: { type: 'geo_point' },
+    },
+    unit: {
+        name: 'GPS',
+        sign: null,
+        type: 'geo_point',
+    },
+};
+//# sourceMappingURL=PositionMeasure.js.map

package/lib/measures/TemperatureMeasure.d.ts

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

package/lib/measures/TemperatureMeasure.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.temperatureMeasure = void 0;
+exports.temperatureMeasure = {
+    valuesMappings: { temperature: { type: 'float' } },
+    unit: {
+        name: 'Degree',
+        sign: '°',
+        type: 'number',
+    },
+};
+//# sourceMappingURL=TemperatureMeasure.js.map

package/lib/measures/index.d.ts

@@ -0,0 +1,5 @@
+export * from './MovementMeasure';
+export * from './PositionMeasure';
+export * from './TemperatureMeasure';
+export * from './HumidityMeasure';
+export * from './BatteryMeasure';

package/lib/measures/index.js

@@ -0,0 +1,22 @@
+"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("./MovementMeasure"), exports);
+__exportStar(require("./PositionMeasure"), exports);
+__exportStar(require("./TemperatureMeasure"), exports);
+__exportStar(require("./HumidityMeasure"), exports);
+__exportStar(require("./BatteryMeasure"), exports);
+//# sourceMappingURL=index.js.map

package/lib/models/BaseAsset.d.ts

@@ -1,56 +1,9 @@
 import { JSONObject } from 'kuzzle';
 import { BaseAssetContent } from '../types';
 export declare class BaseAsset {
+    static id(type: string, model: string, reference: string): string;
     _id: string;
     _source: BaseAssetContent;
     constructor(content: BaseAssetContent, _id?: string);
     serialize(): JSONObject;
 }
-export declare const assetsMappings: {
-    dynamic: string;
-    properties: {
-        type: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        model: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        reference: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        measures: {
-            properties: {};
-        };
-        metadata: {
-            dynamic: string;
-            properties: {};
-        };
-    };
-};
-export declare const assetsHistoryMappings: {
-    dynamic: string;
-    properties: {
-        assetId: {
-            type: string;
-        };
-        measureTypes: {
-            type: string;
-        };
-        asset: any;
-    };
-};

package/lib/models/BaseAsset.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assetsHistoryMappings = exports.assetsMappings = exports.BaseAsset = void 0;
+exports.BaseAsset = void 0;
 class BaseAsset {
     constructor(content, _id) {
-        this._id = _id || `${content.type}-${content.model}-${content.reference}`;
+        this._id = _id || BaseAsset.id(content.type, content.model, content.reference);
         this._source = content;
     }
+    static id(type, model, reference) {
+        return `${type}-${model}-${reference}`;
+    }
     serialize() {
         return {
             _id: this._id,
@@ -14,45 +17,4 @@ class BaseAsset {
     }
 }
 exports.BaseAsset = BaseAsset;
-exports.assetsMappings = {
-    dynamic: 'strict',
-    properties: {
-        type: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        },
-        model: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        },
-        reference: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        },
-        measures: {
-            properties: {
-            // autogenerated from devices mappings
-            }
-        },
-        metadata: {
-            dynamic: 'false',
-            properties: {}
-        }
-    }
-};
-exports.assetsHistoryMappings = {
-    dynamic: 'strict',
-    properties: {
-        assetId: { type: 'keyword' },
-        measureTypes: { type: 'keyword' },
-        // Will be replaced by the custom asset mappings
-        asset: null,
-    }
-};
 //# sourceMappingURL=BaseAsset.js.map

package/lib/models/Config.d.ts

@@ -1,17 +1,5 @@
 import { JSONObject } from 'kuzzle';
-import { CatalogContent } from './Catalog';
-/**
- * Represents either a Rule or Workflow raw configuration document
- */
-export declare type ConfigContent = ConfigCatalogContent | JSONObject;
-/**
- * Content of a configuration document for a catalog entry
- */
-export declare type ConfigCatalogContent = {
-    type: 'catalog';
-    catalog: CatalogContent;
-    _kuzzle_info?: JSONObject;
-};
+export declare type ConfigContent = JSONObject;
 /**
  * Class to manipulate configuration documents
  */

package/lib/models/Device.d.ts

@@ -1,102 +1,11 @@
-import { JSONObject } from 'kuzzle';
 import { DeviceContent } from '../types';
 export declare class Device {
+    static id(model: string, reference: string): string;
     _id: string;
     _source: DeviceContent;
     constructor(content: DeviceContent, _id?: string);
-    serialize(): JSONObject;
-}
-export declare const devicesMappings: {
-    dynamic: string;
-    properties: {
-        reference: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        model: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        measures: {
-            properties: {
-                temperature: {
-                    properties: {
-                        updatedAt: {
-                            type: string;
-                        };
-                        payloadUuid: {
-                            type: string;
-                        };
-                        degree: {
-                            type: string;
-                        };
-                    };
-                };
-                position: {
-                    properties: {
-                        updatedAt: {
-                            type: string;
-                        };
-                        payloadUuid: {
-                            type: string;
-                        };
-                        point: {
-                            type: string;
-                        };
-                        altitude: {
-                            type: string;
-                        };
-                        accuracy: {
-                            type: string;
-                        };
-                    };
-                };
-                movement: {
-                    properties: {
-                        updatedAt: {
-                            type: string;
-                        };
-                        payloadUuid: {
-                            type: string;
-                        };
-                        moving: {
-                            type: string;
-                        };
-                    };
-                };
-            };
-        };
-        qos: {
-            dynamic: string;
-            properties: {};
-        };
-        metadata: {
-            dynamic: string;
-            properties: {};
-        };
-        assetId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        tenantId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
+    serialize(): {
+        _id: string;
+        _source: DeviceContent;
     };
-};
+}

package/lib/models/Device.js

@@ -1,15 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.devicesMappings = exports.Device = void 0;
+exports.Device = void 0;
 class Device {
     constructor(content, _id) {
-        this._id = _id || `${content.model}-${content.reference}`;
+        this._id = _id || Device.id(content.model, content.reference);
         this._source = {
-            qos: {},
             metadata: {},
             ...content
         };
     }
+    static id(model, reference) {
+        return `${model}-${reference}`;
+    }
     serialize() {
         return {
             _id: this._id,
@@ -18,74 +20,4 @@ class Device {
     }
 }
 exports.Device = Device;
-exports.devicesMappings = {
-    dynamic: 'strict',
-    properties: {
-        reference: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        },
-        model: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        },
-        measures: {
-            properties: {
-                temperature: {
-                    properties: {
-                        // common
-                        updatedAt: { type: 'date' },
-                        payloadUuid: { type: 'keyword' },
-                        // temperature
-                        degree: { type: 'float' }
-                    }
-                },
-                position: {
-                    properties: {
-                        // common
-                        updatedAt: { type: 'date' },
-                        payloadUuid: { type: 'keyword' },
-                        // position
-                        point: { type: 'geo_point' },
-                        altitude: { type: 'float' },
-                        accuracy: { type: 'integer' },
-                    }
-                },
-                movement: {
-                    properties: {
-                        // common
-                        updatedAt: { type: 'date' },
-                        payloadUuid: { type: 'keyword' },
-                        // movement state
-                        moving: { type: 'boolean' },
-                    }
-                }
-            }
-        },
-        qos: {
-            dynamic: 'false',
-            properties: {},
-        },
-        metadata: {
-            dynamic: 'false',
-            properties: {},
-        },
-        assetId: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        },
-        tenantId: {
-            type: 'keyword',
-            fields: {
-                text: { type: 'text' }
-            }
-        }
-    }
-};
 //# sourceMappingURL=Device.js.map

package/lib/models/index.d.ts

@@ -1,3 +1,2 @@
 export * from './Device';
 export * from './BaseAsset';
-export * from './Catalog';

package/lib/models/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];
@@ -12,5 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Device"), exports);
 __exportStar(require("./BaseAsset"), exports);
-__exportStar(require("./Catalog"), exports);
 //# sourceMappingURL=index.js.map

package/lib/types/BaseAssetContent.d.ts

@@ -1,8 +1,13 @@
-import { JSONObject } from "kuzzle";
-export interface BaseAssetContent {
+import { JSONObject } from 'kuzzle';
+import { KDocumentContent } from 'kuzzle-sdk';
+import { MeasureContent } from './measures/MeasureContent';
+/**
+ * Asset document
+ */
+export interface BaseAssetContent extends KDocumentContent {
     type: string;
     model: string;
     reference: string;
-    measures?: JSONObject;
+    measures?: MeasureContent[];
     metadata?: JSONObject;
 }

package/lib/types/DecodedPayload.d.ts

@@ -0,0 +1,42 @@
+import { Measurement } from './measures/Measurement';
+/**
+ * Result of the `Decoder.decode` method.
+ *
+ * Contains the decoded measures.
+ *
+ * @example
+ *
+ *  const decodedPayload: DecodedPayload = {
+ *    reference: 'BZH42AZF',
+ *    measures: {
+ *      temperature: {
+ *        measuredAt: Date.now(),
+ *        values: {
+ *          temperature: 23.8,
+ *        }
+ *      },
+ *      position: {
+ *        measuredAt: Date.now(),
+ *        values: {
+ *          position: {
+ *            lat: 21.297,
+ *            lon: 4.8421,
+ *          },
+ *          accuracy: 100,
+ *        }
+ *      },
+ *    },
+ *  };
+ */
+export interface DecodedPayload {
+    /**
+     * Device unique reference
+     */
+    reference: string;
+    /**
+     * Array of decoded measures.
+     */
+    measures: {
+        [measureType: string]: Measurement;
+    };
+}

package/lib/types/{AssetsHistoryContent.js → DecodedPayload.js}

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

package/lib/types/DecoderContent.d.ts

@@ -0,0 +1,4 @@
+export interface DecoderContent {
+    deviceModel: string;
+    deviceMeasures: string[];
+}

package/lib/types/DecoderContent.js

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

package/lib/types/DeviceContent.d.ts

@@ -1,24 +1,20 @@
 import { JSONObject } from 'kuzzle';
-import { DeviceMeasures } from './Measure';
-export declare type DeviceContent = {
-    /**
-     * Device unique reference for a model
-     */
-    reference: string;
-    /**
-     * Device measures gathered from a payload
-     */
-    measures?: DeviceMeasures;
+import { KDocumentContent } from 'kuzzle-sdk';
+import { MeasureContent } from './measures/MeasureContent';
+export interface DeviceContent extends KDocumentContent {
     /**
      * Device model
      * (This will be auto-filled by Kuzzle)
      */
     model?: string;
     /**
-     * Device additionnal informations gathered from a payload
-     * (e.g. battery, network strength, etc.)
+     * Device unique reference for a model
      */
-    qos?: JSONObject;
+    reference: string;
+    /**
+     *
+     */
+    measures?: MeasureContent[];
     /**
      * Device metadata
      */
@@ -28,35 +24,7 @@ export declare type DeviceContent = {
      */
     assetId?: string;
     /**
-     * Attached tenant ID (index name)
+     * Attached engine ID (index name)
      */
-    tenantId?: string;
-    /**
-     * Document metadata
-     * @todo use DocumentMetadata when it's not an interface anymore
-     */
-    _kuzzle_info?: {
-        author?: string;
-        createdAt?: number;
-        updater?: string | null;
-        updatedAt?: number | null;
-    };
-};
-export declare type DeviceBulkContent = {
-    tenantId?: string;
-    deviceId: string;
-    assetId?: string;
-};
-export declare type DeviceBulkBuildedContent = {
-    tenantId: string;
-    deviceIds: string[];
-    assetIds: string[];
-};
-export declare type DeviceMAttachementContent = {
-    errors: JSONObject[];
-    successes: JSONObject[];
-};
-export declare type DeviceMRequestContent = {
-    _id: string;
-    body: JSONObject;
-};
+    engineId?: string;
+}

package/lib/types/DeviceManagerConfiguration.d.ts

@@ -0,0 +1,40 @@
+import { JSONObject } from 'kuzzle';
+export declare type DeviceManagerConfiguration = {
+    /**
+     * Administration index name
+     */
+    adminIndex: string;
+    /**
+     * Administration collections mappings (in admin index)
+     */
+    adminCollections: {
+        config: {
+            name: string;
+            mappings: JSONObject;
+            settings: JSONObject;
+        };
+        devices: {
+            name: string;
+            mappings: JSONObject;
+            settings: JSONObject;
+        };
+        payloads: {
+            name: string;
+            mappings: JSONObject;
+            settings: JSONObject;
+        };
+    };
+    engineCollections: {
+        config: {
+            name: string;
+            mappings: JSONObject;
+            settings: JSONObject;
+        };
+    };
+    /**
+     * Interval to write documents from the buffer
+     *
+     * @see https://docs.kuzzle.io/sdk/js/7/essentials/batch-processing/
+     */
+    batchInterval: number;
+};

package/lib/types/DeviceManagerConfiguration.js

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

package/lib/types/index.d.ts

@@ -1,3 +1,8 @@
-export * from './Measure';
-export * from './DeviceContent';
 export * from './BaseAssetContent';
+export * from './DeviceContent';
+export * from './measures/MeasureContent';
+export * from './measures/Measurement';
+export * from './measures/MeasureDefinition';
+export * from './DecoderContent';
+export * from './DecodedPayload';
+export * from './DeviceManagerConfiguration';