kuzzle-device-manager-types 2.4.0-beta.6 → 2.4.0-beta.8

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

@@ -1,9 +1,7 @@
 import { DeviceManagerPlugin } from "../plugin";
+import { BaseService } from "../shared";
 import { AssetHistoryContent, AssetHistoryEvent } from "./types/AssetHistoryContent";
-export declare class AssetHistoryService {
-    private context;
-    private config;
-    private get sdk();
+export declare class AssetHistoryService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     add<TAssetHistoryEvent extends AssetHistoryEvent>(engineId: string, histories: AssetHistoryContent[]): Promise<void>;
 }

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

@@ -1,39 +1,22 @@
-import { User } from "kuzzle";
+import { KuzzleRequest, User } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult, mReplaceResponse } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
-import { Metadata } from "../shared";
+import { Metadata, BaseService, SearchParams } from "../shared";
 import { AssetHistoryService } from "./AssetHistoryService";
 import { AssetContent } from "./types/AssetContent";
 import { ApiAssetMigrateTenantResult } from "./types/AssetApi";
-export declare class AssetService {
-    private context;
-    private config;
+export declare class AssetService extends BaseService {
     private assetHistoryService;
-    private get sdk();
-    private get app();
-    private get impersonatedSdk();
     constructor(plugin: DeviceManagerPlugin, assetHistoryService: AssetHistoryService);
     registerAskEvents(): void;
-    get(engineId: string, assetId: string): Promise<KDocument<AssetContent>>;
+    get(engineId: string, assetId: string, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
     /**
      * Updates an asset metadata
      */
-    update(user: User, engineId: string, assetId: string, metadata: Metadata, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<AssetContent>>;
-    create(user: User, engineId: string, model: string, reference: string, metadata: JSONObject, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<AssetContent>>;
-    delete(user: User, engineId: string, assetId: string, { refresh, strict }: {
-        refresh: any;
-        strict: boolean;
-    }): Promise<void>;
-    search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
-        from?: number;
-        size?: number;
-        scroll?: string;
-        lang?: string;
-    }): Promise<SearchResult<KHit<AssetContent>>>;
+    update(engineId: string, assetId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    create(engineId: string, model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<AssetContent>>;
+    delete(engineId: string, assetId: string, request: KuzzleRequest): Promise<void>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<AssetContent>>>;
     migrateTenant(user: User, assetsList: string[], engineId: string, newEngineId: string): Promise<ApiAssetMigrateTenantResult>;
     /**
      * Replace an asset metadata

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

@@ -49,4 +49,4 @@ export type AssetMeasureContext<TMetadata extends Metadata = Metadata> = {
      * Name of the measure for the Asset
      */
     measureName: string;
-} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata">;
+} & Pick<AssetContent<JSONObject, TMetadata>, "model" | "reference" | "metadata" | "groups">;

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

@@ -3,12 +3,9 @@ import { JSONObject, KDocument } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
 import { DeviceContent } from "../device";
 import { DecodedMeasurement } from "../measure";
+import { BaseService } from "../shared";
 import { Decoder } from "./Decoder";
-export declare class PayloadService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
+export declare class PayloadService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     /**
      * Process a payload by validating and decode it with the `decoder` associated

package/dist/lib/modules/device/DeviceService.d.ts

@@ -1,17 +1,13 @@
-import { Plugin, User } from "kuzzle";
+import { KuzzleRequest } from "kuzzle";
 import { JSONObject, KDocument, KHit, SearchResult } from "kuzzle-sdk";
 import { AssetContent } from "./../asset";
-import { Metadata } from "../shared";
+import { DeviceManagerPlugin } from "../plugin";
+import { Metadata, BaseService, SearchParams } from "../shared";
 import { DecodedMeasurement } from "../measure";
 import { DeviceContent } from "./types/DeviceContent";
 import { ApiDeviceLinkAssetRequest } from "./types/DeviceApi";
-export declare class DeviceService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
-    private get impersonatedSdk();
-    constructor(plugin: Plugin);
+export declare class DeviceService extends BaseService {
+    constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
     /**
      * Create a new device.
@@ -20,23 +16,11 @@ export declare class DeviceService {
      * method since in this case "engineId" is not really an engine ID but still
      * required as an argument (in part to check the tenant rights)
      */
-    create(user: User, model: string, reference: string, metadata: JSONObject, { engineId, refresh, }?: {
-        engineId?: string;
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
-    get(index: string, deviceId: string): Promise<KDocument<DeviceContent>>;
-    update(user: User, engineId: string, deviceId: string, metadata: Metadata, { refresh }: {
-        refresh: any;
-    }): Promise<KDocument<DeviceContent>>;
-    delete(user: User, engineId: string, deviceId: string, { refresh }: {
-        refresh: any;
-    }): Promise<void>;
-    search(engineId: string, searchBody: JSONObject, { from, size, scroll, lang, }: {
-        from?: number;
-        size?: number;
-        scroll?: string;
-        lang?: string;
-    }): Promise<SearchResult<KHit<DeviceContent>>>;
+    create(model: string, reference: string, metadata: JSONObject, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    get(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    update(engineId: string, deviceId: string, metadata: Metadata, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
+    delete(engineId: string, deviceId: string, request: KuzzleRequest): Promise<void>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<SearchResult<KHit<DeviceContent>>>;
     /**
      * Attach the device to an engine
      *
@@ -45,29 +29,22 @@ export declare class DeviceService {
      * @param options.refresh Wait for ES indexation
      * @param options.strict If true, throw if an operation isn't possible
      */
-    attachEngine(user: User, engineId: string, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
+    attachEngine(engineId: string, deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Detach a device from its attached engine
      *
-     * @param deviceId Device id
-     * @param options.refresh Wait for ES indexation
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
      */
-    detachEngine(user: User, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<KDocument<DeviceContent>>;
+    detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceContent>>;
     /**
      * Link a device to an asset.
      */
-    linkAsset(user: User, engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], { refresh, implicitMeasuresLinking, }?: {
-        refresh?: any;
-        implicitMeasuresLinking?: boolean;
-    }): Promise<{
+    linkAsset(engineId: string, deviceId: string, assetId: string, measureNames: ApiDeviceLinkAssetRequest["body"]["measureNames"], implicitMeasuresLinking: boolean, request: KuzzleRequest): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;
-    receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[]): Promise<void>;
+    receiveMeasures(engineId: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[], request: KuzzleRequest): Promise<void>;
     /**
      * Checks if the asset does not already have a linked device using one of the
      * requested measure names.
@@ -83,12 +60,10 @@ export declare class DeviceService {
     /**
      * Unlink a device of an asset
      *
-     * @param deviceId Id of the device
-     * @param options.refresh Wait for ES indexation
+     * @param {string} deviceId Id of the device
+     * @param {KuzzleRequest} request kuzzle request
      */
-    unlinkAsset(user: User, deviceId: string, { refresh }?: {
-        refresh?: any;
-    }): Promise<{
+    unlinkAsset(deviceId: string, request: KuzzleRequest): Promise<{
         asset: KDocument<AssetContent>;
         device: KDocument<DeviceContent>;
     }>;

package/dist/lib/modules/device/collections/deviceMappings.d.ts

@@ -1,51 +1,7 @@
+import { CollectionMappings } from "kuzzle";
 /**
  * Base mappings for the "devices" collection.
  *
  * Those mappings does not contains the `measures` and `metadata` mappings.
  */
-export declare const devicesMappings: {
-    dynamic: string;
-    properties: {
-        model: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        reference: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        assetId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        engineId: {
-            type: string;
-            fields: {
-                text: {
-                    type: string;
-                };
-            };
-        };
-        metadata: {
-            properties: {};
-        };
-        measures: {
-            properties: {};
-        };
-        lastMeasuredAt: {
-            type: string;
-        };
-    };
-};
+export declare const devicesMappings: CollectionMappings;

package/dist/lib/modules/measure/MeasureService.d.ts

@@ -1,13 +1,9 @@
 import { JSONObject, KDocument } from "kuzzle";
 import { DeviceContent } from "../device";
 import { DeviceManagerPlugin } from "../plugin";
-import { Metadata } from "../shared";
+import { BaseService, Metadata } from "../shared";
 import { DecodedMeasurement } from "./types/MeasureContent";
-export declare class MeasureService {
-    private config;
-    private context;
-    private get sdk();
-    private get app();
+export declare class MeasureService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     /**
      * Register new measures from a device, updates :

package/dist/lib/modules/measure/collections/measuresMappings.d.ts

@@ -35,6 +35,21 @@ export declare const measuresMappings: {
                 metadata: {
                     properties: {};
                 };
+                groups: {
+                    properties: {
+                        id: {
+                            type: string;
+                            fields: {
+                                text: {
+                                    type: string;
+                                };
+                            };
+                        };
+                        date: {
+                            type: string;
+                        };
+                    };
+                };
             };
         };
         /**

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

@@ -1,10 +1,8 @@
 import { JSONObject, KDocument } from "kuzzle-sdk";
 import { DeviceManagerPlugin } from "../plugin";
+import { BaseService } from "../shared";
 import { AssetModelContent, DeviceModelContent, MeasureModelContent } from "./types/ModelContent";
-export declare class ModelService {
-    private config;
-    private context;
-    private get sdk();
+export declare class ModelService extends BaseService {
     constructor(plugin: DeviceManagerPlugin);
     registerAskEvents(): void;
     writeAsset(engineGroup: string, model: string, metadataMappings: JSONObject, defaultMetadata: JSONObject, measures: AssetModelContent["asset"]["measures"]): Promise<KDocument<AssetModelContent>>;

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

@@ -1,2 +1,2 @@
-export * from "./types/DeviceManagerConfiguration";
+export * from "./types/exports";
 export * from "./DeviceManagerPlugin";

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

@@ -1,4 +1,3 @@
-export * from "./types/DeviceManagerConfiguration";
+export * from "./types";
 export * from "./DeviceManagerEngine";
 export * from "./DeviceManagerPlugin";
-export * from "./types/InternalCollection";

package/dist/lib/modules/plugin/types/DeviceManagerConfiguration.d.ts

@@ -1,4 +1,4 @@
-import { JSONObject } from "kuzzle-sdk";
+import { CollectionMappings, JSONObject } from "kuzzle-sdk";
 export type DeviceManagerConfiguration = {
     /**
      * Ignore errors at startup such as wrong mappings update.
@@ -45,5 +45,13 @@ export type DeviceManagerConfiguration = {
             mappings: JSONObject;
             settings: JSONObject;
         };
+        asset: {
+            name: string;
+            mappings: CollectionMappings;
+        };
+        device: {
+            name: string;
+            mappings: CollectionMappings;
+        };
     };
 };

package/dist/lib/modules/plugin/types/Pipes.d.ts

@@ -0,0 +1,17 @@
+import { JSONObject, KDocumentContent, KHit, KuzzleRequest } from "kuzzle";
+export interface SearchQueryResult<T extends KDocumentContent> {
+    aggregations?: JSONObject;
+    hits: Array<KHit<T>>;
+    remaining: unknown;
+    scrollId: string;
+    suggest: JSONObject;
+    total: number;
+}
+export type EventGenericDocumentBeforeSearch = {
+    name: `generic:document:beforeSearch`;
+    args: [JSONObject, KuzzleRequest];
+};
+export type EventGenericDocumentAfterSearch<T extends KDocumentContent = KDocumentContent> = {
+    name: `generic:document:afterSearch`;
+    args: [SearchQueryResult<T>, KuzzleRequest];
+};

package/dist/lib/modules/plugin/types/exports.d.ts

@@ -0,0 +1 @@
+export * from "./DeviceManagerConfiguration";

package/dist/lib/modules/plugin/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./DeviceManagerConfiguration";
+export * from "./InternalCollection";
+export * from "./Pipes";

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

@@ -0,0 +1,69 @@
+import { ArgsDocumentControllerCreate, ArgsDocumentControllerDelete, ArgsDocumentControllerUpdate, Backend, EmbeddedSDK, KDocument, KDocumentContent, KHit, KuzzleRequest, SearchResult, User } from "kuzzle";
+import { DeviceManagerPlugin, DeviceManagerConfiguration, InternalCollection } from "../../plugin";
+interface PayloadRequest {
+    collection: InternalCollection;
+    engineId: string;
+}
+export type SearchParams = ReturnType<KuzzleRequest["getSearchParams"]>;
+export declare abstract class BaseService {
+    private plugin;
+    constructor(plugin: DeviceManagerPlugin);
+    protected get app(): Backend;
+    protected get sdk(): EmbeddedSDK;
+    protected get config(): DeviceManagerConfiguration;
+    protected get impersonatedSdk(): (user: User) => EmbeddedSDK;
+    protected normalizeKuzzleRequest(request: KuzzleRequest, { collection, engineId }: PayloadRequest): KuzzleRequest;
+    /**
+     * Wrapper to SDK create method with trigger generic:document events
+     *
+     * @param {KuzzleRequest} request
+     * @param {KDocument} documentId
+     * @param {PayloadRequest} payload
+     * @param {ArgsDocumentControllerCreate} [options]
+     * @returns {Promise<KDocument>}
+     */
+    protected getDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, documentId: string, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerCreate): Promise<KDocument<T>>;
+    /**
+     * Wrapper to SDK create method with trigger generic:document events
+     *
+     * @param {KuzzleRequest} request
+     * @param {KDocument} document
+     * @param {PayloadRequest} payload
+     * @param {ArgsDocumentControllerCreate} [options]
+     * @returns {Promise<KDocument>}
+     */
+    protected createDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, document: KDocument<T>, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerCreate): Promise<KDocument<T>>;
+    /**
+     * Wrapper to SDK update method with trigger generic:document events
+     *
+     * @param {KuzzleRequest} request
+     * @param {KDocument} document
+     * @param {PayloadRequest} payload
+     * @param {ArgsDocumentControllerUpdate} [options]
+     * @returns {Promise<KDocument>}
+     */
+    protected updateDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, document: KDocument<Partial<T>>, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerUpdate): Promise<KDocument<T>>;
+    /**
+     * Wrapper to SDK delete method with trigger generic:document events
+     *
+     * @param {KuzzleRequest} request
+     * @param {string} documentId
+     * @param {PayloadRequest} payload
+     * @param {ArgsDocumentControllerUpdate} [options]
+     * @returns {Promise<{ _id: string }>}
+     */
+    protected deleteDocument(request: KuzzleRequest, documentId: string, { collection, engineId }: PayloadRequest, options?: ArgsDocumentControllerDelete): Promise<{
+        _id: string;
+    }>;
+    /**
+     * Wrapper to SDK search method with trigger generic:document events
+     * ! Caution the pipes are not applied on next()
+     *
+     * @param {KuzzleRequest} request
+     * @param {ArgsDocumentControllerUpdate} [options]
+     * @param {PayloadRequest} payload
+     * @returns {Promise<SearchResult<KHit>>}
+     */
+    protected searchDocument<T extends KDocumentContent = KDocumentContent>(request: KuzzleRequest, { from, size, scrollTTL: scroll }: SearchParams, { collection, engineId }: PayloadRequest): Promise<SearchResult<KHit<T>>>;
+}
+export {};

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

@@ -1,2 +1,3 @@
 export * from "./AbstractExporter";
+export * from "./BaseService";
 export * from "./DigitalTwinExporter";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager-types",
-  "version": "2.4.0-beta.6",
+  "version": "2.4.0-beta.8",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",