kuzzle-device-manager-types 2.4.0-beta.16 → 2.4.0-beta.18

package/dist/lib/modules/asset/AssetService.d.ts

@@ -14,6 +14,10 @@ export declare class AssetService extends BaseService {
      * Update an asset metadata
      */
     update(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    /**
+     * Replace an asset metadata
+     */
+    replaceMetadata(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Update or Create an asset metadata
      */

package/dist/lib/modules/asset/AssetsController.d.ts

@@ -1,7 +1,7 @@
 import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { AssetService } from "./AssetService";
-import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult } from "./types/AssetApi";
+import { ApiAssetCreateResult, ApiAssetUpsertResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult, ApiAssetMigrateTenantResult, ApiAssetMetadataReplaceResult } from "./types/AssetApi";
 export declare class AssetsController {
     private plugin;
     private assetService;
@@ -12,6 +12,7 @@ export declare class AssetsController {
     get(request: KuzzleRequest): Promise<ApiAssetGetResult>;
     upsert(request: KuzzleRequest): Promise<ApiAssetUpsertResult>;
     update(request: KuzzleRequest): Promise<ApiAssetUpdateResult>;
+    replaceMetadata(request: KuzzleRequest): Promise<ApiAssetMetadataReplaceResult>;
     create(request: KuzzleRequest): Promise<ApiAssetCreateResult>;
     delete(request: KuzzleRequest): Promise<ApiAssetDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiAssetSearchResult>;

package/dist/lib/modules/asset/types/AssetApi.d.ts

@@ -20,6 +20,15 @@ export interface ApiAssetUpdateRequest extends AssetsControllerRequest {
     };
 }
 export type ApiAssetUpdateResult = KDocument<AssetContent>;
+export interface ApiAssetMetadataReplaceRequest extends AssetsControllerRequest {
+    action: "replaceMetadata";
+    _id: string;
+    refresh?: string;
+    body: {
+        metadata: Metadata;
+    };
+}
+export type ApiAssetMetadataReplaceResult = KDocument<AssetContent>;
 export interface ApiAssetUpsertRequest extends AssetsControllerRequest {
     action: "upsert";
     _id: string;

package/dist/lib/modules/decoder/Decoder.d.ts

@@ -19,6 +19,17 @@ export type NamedMeasures = Array<{
  */
 export declare abstract class Decoder {
     private _http?;
+    /**
+     * Internal logger.
+     */
+    log: {
+        debug: (message: any) => void;
+        error: (message: any) => void;
+        info: (message: any) => void;
+        silly: (message: any) => void;
+        verbose: (message: any) => void;
+        warn: (message: any) => void;
+    };
     /**
      * Device model name.
      *

package/dist/lib/modules/measure/types/MeasureDefinition.d.ts

@@ -1,15 +1,40 @@
 import { JSONObject } from "kuzzle-sdk";
+interface MeasureLocales {
+    [localeString: string]: {
+        friendlyName: string;
+        unit?: string;
+    };
+}
+export interface MeasureValuesDetails {
+    [valueName: string]: MeasureLocales;
+}
 /**
  * Represents a measure definition registered by the Device Manager
  *
  * @example
- * {
- *   valuesMappings: { temperature: { type: 'float' } },
- * }
+ *{
+ * valuesMappings: { temperature: { type: "float" } },
+ * valuesDetails: {
+ *   temperature: {
+ *     en: {
+ *       friendlyName: "Temperature",
+ *       unit: "°C",
+ *     },
+ *     fr: {
+ *       friendlyName: "Température",
+ *       unit: "°C",
+ *     },
+ *   },
+ * },
+ *}
  */
 export interface MeasureDefinition {
     /**
      * Mappings for the measurement values in order to index the fields
      */
     valuesMappings: JSONObject;
+    valuesDetails?: {
+        [valueName: string]: MeasureLocales;
+    };
 }
+export {};

package/dist/lib/modules/model/MappingsConflictsError.d.ts

@@ -0,0 +1,7 @@
+import { JSONObject, KuzzleError } from "kuzzle";
+export declare class MappingsConflictsError extends KuzzleError {
+    private conflicts;
+    constructor(message: string, conflicts: JSONObject, id?: string, code?: number);
+    get name(): string;
+    toJSON(): JSONObject;
+}

package/dist/lib/modules/model/ModelService.d.ts

@@ -2,13 +2,15 @@ import { JSONObject, KDocument } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { BaseService } from "../shared";
 import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings } from "./types/ModelContent";
+import { MeasureValuesDetails } from "../measure";
 export declare class ModelService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
+    private checkModelsConflicts;
     writeAsset(engineGroup: string, model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: AssetModelContent["asset"]["measures"]): Promise<KDocument<AssetModelContent>>;
     private checkDefaultValues;
     writeDevice(model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: DeviceModelContent["device"]["measures"]): Promise<KDocument<DeviceModelContent>>;
-    writeMeasure(type: string, valuesMappings: JSONObject): Promise<KDocument<MeasureModelContent>>;
+    writeMeasure(type: string, valuesMappings: JSONObject, valuesDetails?: MeasureValuesDetails): Promise<KDocument<MeasureModelContent>>;
     deleteAsset(_id: string): Promise<void>;
     deleteDevice(_id: string): Promise<void>;
     deleteMeasure(_id: string): Promise<void>;

package/dist/lib/modules/model/ModelsConflicts.d.ts

@@ -0,0 +1,30 @@
+import { TwinModelContent, TwinType } from "../plugin";
+import { MeasureModelContent } from "./exports";
+export type ConflictChunk = {
+    sourceModel: string;
+    newModel: string;
+    modelType: string;
+    conflicts: MappingsConflict[];
+};
+export type MappingsConflict = {
+    path: string;
+    currentType: string | undefined;
+    newType: string | undefined;
+};
+/**
+ * Return every conflicts between the mappings of twins and a new twin model
+ *
+ * @param twinType The target twin type
+ * @param models The already present twin models
+ * @param additional The new asset
+ * @returns An array of ConflictChunk between current twins and the new twin
+ */
+export declare function getTwinConflicts<TDigitalTwin extends TwinModelContent>(twinType: TwinType, models: TDigitalTwin[], additional: TDigitalTwin): ConflictChunk[];
+/**
+ * Return every conflicts between the mappings of measure models and a new measure model
+ *
+ * @param measures The already present measure models
+ * @param additional The new measure
+ * @returns An array of ConflictChunk between current measures and the new measure
+ */
+export declare function getMeasureConflicts(measures: MeasureModelContent[], additional: MeasureModelContent): ConflictChunk[];

package/dist/lib/modules/model/types/ModelApi.d.ts

@@ -1,5 +1,6 @@
 import { JSONObject, KDocument } from "kuzzle-sdk";
 import { AssetModelContent, DeviceModelContent, MeasureModelContent, MetadataDetails, MetadataGroups, MetadataMappings } from "./ModelContent";
+import { MeasureValuesDetails } from "../../measure/types/MeasureDefinition";
 interface ModelsControllerRequest {
     controller: "device-manager/models";
 }
@@ -49,6 +50,7 @@ export interface ApiModelWriteMeasureRequest extends ModelsControllerRequest {
     body: {
         type: string;
         valuesMappings: JSONObject;
+        valuesDetails?: MeasureValuesDetails;
     };
 }
 export type ApiModelWriteMeasureResult = KDocument<MeasureModelContent>;

package/dist/lib/modules/model/types/ModelContent.d.ts

@@ -9,14 +9,17 @@ export interface MeasureModelContent extends KDocumentContent {
 }
 interface MetadataProperty {
     type: string;
+    strategy?: string;
+    format?: string;
 }
-export interface MetadataMappings {
-    [key: string]: MetadataProperty | {
-        properties: {
-            [key: string]: MetadataProperty;
-        };
+interface MetadataObject {
+    properties: {
+        [key: string]: MetadataProperty | MetadataObject;
     };
 }
+export interface MetadataMappings {
+    [key: string]: MetadataProperty | MetadataObject;
+}
 interface LocaleDetails {
     friendlyName: string;
     description: string;

package/dist/lib/modules/plugin/DeviceManagerEngine.d.ts

@@ -1,8 +1,20 @@
-import { Backend, Plugin } from "kuzzle";
+import { Backend, KDocumentContent, Plugin } from "kuzzle";
 import { AbstractEngine, ConfigManager, EngineContent } from "kuzzle-plugin-commons";
+import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "../model";
 import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
 import { InternalCollection } from "./types/InternalCollection";
+import { ConflictChunk } from "../model/ModelsConflicts";
+export type TwinType = "asset" | "device";
+export type TwinModelContent = AssetModelContent | DeviceModelContent;
+export interface EngineDocument extends KDocumentContent {
+    type: "engine-device-manager";
+    engine: {
+        group: string;
+        index: string;
+        name: string;
+    };
+}
 export type AskEngineList = {
     name: "ask:device-manager:engine:list";
     payload: {
@@ -15,11 +27,48 @@ export type AskEngineUpdateAll = {
     payload: void;
     result: void;
 };
+export type AskEngineUpdateConflict = {
+    name: "ask:device-manager:engine:doesUpdateConflict";
+    payload: {
+        twin?: {
+            type: TwinType;
+            models: TwinModelContent[];
+        };
+        measuresModels?: MeasureModelContent[];
+    };
+    result: ConflictChunk[];
+};
 export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlugin> {
     config: DeviceManagerConfiguration;
     get app(): Backend;
     constructor(plugin: Plugin, adminConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    /**
+     * Return conflicts between the new and already present twin models
+     *
+     * @param twinType The target twin type
+     * @param twinModels The already present twin models
+     * @param additionalModels The new or updated twin models
+     * @param measureModels The already present measures models
+     *
+     * @throws If a measure type declared in the twin does not exists
+     * @returns An array of conflict chunk
+     */
+    private doesTwinUpdateConflicts;
+    /**
+     * Return conflicts between the new and already present measure models
+     *
+     * @param measuresModels The already present measure models
+     * @param additionalMeasures The new or updated measure models
+     * @returns An array of ConflictChunk
+     */
+    private doesMeasuresUpdateConflicts;
     updateEngines(): Promise<void>;
+    /**
+     * Search and return every engines in use
+     *
+     * @returns An array of the available engines
+     */
+    getEngines(): Promise<EngineDocument[]>;
     onCreate(index: string, group?: string): Promise<{
         collections: any[];
     }>;
@@ -29,12 +78,100 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     onDelete(index: string): Promise<{
         collections: InternalCollection[];
     }>;
+    /**
+     * Generate assets mappings and create the assets collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the assets collection creation
+     */
     createAssetsCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    /**
+     * Generate assets mappings and create the assets history collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the assets history collection creation
+     */
     createAssetsHistoryCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    /**
+     * Create the assets groups collection with the assets groups mappings in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the assets groups collection creation
+     */
     createAssetsGroupsCollection(engineId: string): Promise<InternalCollection>;
-    private getDigitalTwinMappings;
+    /**
+     * Generate devices mappings and create the devices collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the devices collection creation
+     */
     createDevicesCollection(engineId: string): Promise<InternalCollection>;
+    /**
+     * Generate measures mappings and create the measures collection in the engine
+     *
+     * @param engineId The target engine Id
+     * @param engineGroup The engine group
+     *
+     * @throws If it failed during the measures collection creation
+     */
     createMeasuresCollection(engineId: string, engineGroup: string): Promise<InternalCollection>;
+    /**
+     * Create a collection with custom mappings in an engine
+     *
+     * @param engineIndex The target engine
+     * @param collection The collection name
+     * @param mappings The collection mappings
+     *
+     * @throws If it failed to create the collection
+     */
+    private tryCreateCollection;
+    /**
+     * Generate ES mappings from twin models and theirs associated measures, all fetched from the database
+     *
+     * @param digitalTwinType The target twin type
+     * @param engineGroup The twin engine group
+     * @returns The complete ES mappings produces by merging all the target type twins
+     */
+    private getDigitalTwinMappingsFromDB;
+    /**
+     * Generate ES mappings from twin models and theirs associated measures
+     *
+     * @param digitalTwinType The target twin type
+     * @param models The twin models
+     * @param measureModels The associated measures
+     * @returns The complete ES mappings produces by merging all the target type twins
+     */
+    private getDigitalTwinMappings;
+    /**
+     * Generate ES mappings from measures and theirs associated assets, all fetched via the database
+     *
+     * @param engineGroup The target engine group
+     * @returns The complete ES mappings produced by merging models mappings
+     */
+    private getMeasuresMappingsFromDB;
+    /**
+     * Generate ES mappings from measures and theirs associated assets
+     *
+     * @param models The measures models
+     * @param assetsMappings The assets complete mappings
+     * @returns The complete ES mappings produced by merging models mappings
+     */
     private getMeasuresMappings;
+    /**
+     * Retrieve a certain type of models associated to an engine
+     *
+     * @param engineId The target engine Id
+     * @param type The desired model type
+     * @param engineGroup The target engine group
+     * @returns An array of the generic type provided
+     */
     private getModels;
 }

package/dist/lib/modules/shared/services/AbstractExporter.d.ts

@@ -20,6 +20,7 @@ export interface Column {
     header: string;
     path: string;
     isMeasure?: boolean;
+    isIsoDate?: boolean;
 }
 export declare abstract class AbstractExporter<P extends ExportParams = ExportParams> {
     protected plugin: DeviceManagerPlugin;

package/dist/tests/application/decoders/DummyTempPositionDecoder.d.ts

@@ -11,6 +11,7 @@ export declare class DummyTempPositionDecoder extends Decoder {
         readonly name: "position";
         readonly type: "position";
     }];
+    constructor();
     validate(payload: JSONObject): Promise<boolean>;
     decode(decodedPayload: DecodedPayload<DummyTempPositionDecoder>, payload: JSONObject): Promise<DecodedPayload<DummyTempPositionDecoder>>;
 }

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "kuzzle-device-manager-types",
-  "version": "2.4.0-beta.16",
+  "version": "2.4.0-beta.18",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",
   "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/kuzzleio/kuzzle-plugin-device-manager.git"
+    "url": "git+https://github.com/kuzzleio/kuzzle-plugin-device-manager.git",
+    "directory": "types"
   },
   "scripts": {
     "prepack": "npm run build",
-    "build": "./copy-types.sh && node scripts/copy-version.js"
+    "build": "./copy-types.sh"
   },
   "license": "Apache-2.0",
   "files": [