kuzzle-device-manager-types 2.3.2 → 2.4.0-beta.1-2

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

@@ -1,4 +1,4 @@
-import { ControllerDefinition, HttpStream, KuzzleRequest } from "kuzzle";
+import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { AssetService } from "./AssetService";
 import { ApiAssetCreateResult, ApiAssetDeleteResult, ApiAssetGetMeasuresResult, ApiAssetGetResult, ApiAssetSearchResult, ApiAssetUpdateResult } from "./types/AssetApi";
@@ -6,6 +6,8 @@ export declare class AssetsController {
     private plugin;
     private assetService;
     definition: ControllerDefinition;
+    private exporter;
+    private measureExporter;
     constructor(plugin: DeviceManagerPlugin, assetService: AssetService);
     get(request: KuzzleRequest): Promise<ApiAssetGetResult>;
     update(request: KuzzleRequest): Promise<ApiAssetUpdateResult>;
@@ -13,7 +15,6 @@ export declare class AssetsController {
     delete(request: KuzzleRequest): Promise<ApiAssetDeleteResult>;
     search(request: KuzzleRequest): Promise<ApiAssetSearchResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiAssetGetMeasuresResult>;
-    exportMeasures(request: KuzzleRequest): Promise<HttpStream | {
-        link: string;
-    }>;
+    exportMeasures(request: KuzzleRequest): Promise<any>;
+    export(request: KuzzleRequest): Promise<any>;
 }

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

@@ -54,6 +54,7 @@ export interface ApiAssetGetMeasuresRequest extends AssetsControllerRequest {
     startAt?: string;
     endAt?: string;
     type?: string;
+    lang?: "koncorde" | "elasticsearch";
     body?: {
         query?: JSONObject;
         sort?: JSONObject;
@@ -75,6 +76,7 @@ export interface ApiAssetExportMeasuresRequest extends AssetsControllerRequest {
     startAt?: string;
     endAt?: string;
     type?: string;
+    lang?: "koncorde" | "elasticsearch";
     body?: {
         query?: JSONObject;
         sort?: JSONObject;
@@ -83,4 +85,15 @@ export interface ApiAssetExportMeasuresRequest extends AssetsControllerRequest {
 export type ApiAssetExportMeasuresResult = {
     link: string;
 };
+export interface ApiAssetExportRequest extends AssetsControllerRequest {
+    action: "export";
+    lang?: "koncorde" | "elasticsearch";
+    body?: {
+        query?: JSONObject;
+        sort?: JSONObject;
+    };
+}
+export type ApiAssetExportResult = {
+    link: string;
+};
 export {};

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

@@ -1,4 +1,4 @@
-import { ControllerDefinition, HttpStream, KuzzleRequest } from "kuzzle";
+import { ControllerDefinition, KuzzleRequest } from "kuzzle";
 import { DeviceManagerPlugin } from "../plugin";
 import { DeviceService } from "./DeviceService";
 import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult } from "./types/DeviceApi";
@@ -6,6 +6,8 @@ export declare class DevicesController {
     private plugin;
     private deviceService;
     definition: ControllerDefinition;
+    private exporter;
+    private measureExporter;
     constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService);
     get(request: KuzzleRequest): Promise<ApiDeviceGetResult>;
     update(request: KuzzleRequest): Promise<ApiDeviceUpdateResult>;
@@ -32,8 +34,7 @@ export declare class DevicesController {
      */
     unlinkAsset(request: KuzzleRequest): Promise<ApiDeviceUnlinkAssetResult>;
     getMeasures(request: KuzzleRequest): Promise<ApiDeviceGetMeasuresResult>;
-    exportMeasures(request: KuzzleRequest): Promise<HttpStream | {
-        link: string;
-    }>;
+    exportMeasures(request: KuzzleRequest): Promise<any>;
     receiveMeasures(request: KuzzleRequest): Promise<void>;
+    export(request: KuzzleRequest): Promise<any>;
 }

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

@@ -44,5 +44,8 @@ export declare const devicesMappings: {
         measures: {
             properties: {};
         };
+        lastMeasuredAt: {
+            type: string;
+        };
     };
 };

package/dist/lib/modules/device/types/DeviceApi.d.ts

@@ -121,6 +121,7 @@ export interface ApiDeviceGetMeasuresRequest extends DevicesControllerRequest {
     startAt?: string;
     endAt?: string;
     type?: string;
+    lang?: "koncorde" | "elasticsearch";
     body?: {
         query?: JSONObject;
         sort?: JSONObject;
@@ -142,6 +143,7 @@ export interface ApiDeviceExportMeasuresRequest extends DevicesControllerRequest
     startAt?: string;
     endAt?: string;
     type?: string;
+    lang?: "koncorde" | "elasticsearch";
     body?: {
         query?: JSONObject;
         sort?: JSONObject;
@@ -164,4 +166,15 @@ export interface ApiDeviceReceiveMeasuresRequest<TMeasureValues extends JSONObje
     };
 }
 export type ApiDeviceReceiveMeasuresResult = void;
+export interface ApiDeviceExportRequest extends DevicesControllerRequest {
+    action: "export";
+    lang?: "koncorde" | "elasticsearch";
+    body?: {
+        query?: JSONObject;
+        sort?: JSONObject;
+    };
+}
+export type ApiDeviceExportResult = {
+    link: string;
+};
 export {};

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

@@ -1,37 +1,31 @@
 /// <reference types="node" />
-import { PassThrough } from "node:stream";
-import { JSONObject, User } from "kuzzle";
-import { DeviceManagerPlugin } from "../plugin";
+/// <reference types="node" />
+import { UUID } from "node:crypto";
+import { KHit, User } from "kuzzle";
+import { AbstractExporter, Column, ExportParams } from "../shared";
 import { MeasureContent } from "./exports";
-type ExportOptions = {
-    sort?: JSONObject;
-    query?: JSONObject;
-    from?: number;
-    size?: number;
+interface MeasureSearchParams extends ExportParams {
+    id: string;
+    type?: string;
     startAt?: string;
     endAt?: string;
-    type?: string;
-};
-type ExportParams = {
-    query: JSONObject;
-    target: "asset" | "device";
-    model: string;
-    sort: JSONObject;
+}
+interface MeasuresSearchOptions {
+    from?: number;
+    size?: number;
+}
+interface MeasureExportParams extends ExportParams {
     id: string;
-};
-export declare class MeasureExporter {
-    private plugin;
-    private engineId;
-    private target?;
-    private get sdk();
-    constructor(plugin: DeviceManagerPlugin, engineId: string, { target }?: {
-        target?: "asset" | "device";
-    });
+    model: string;
+}
+export declare class MeasureExporter extends AbstractExporter<MeasureExportParams> {
+    protected exportRedisKey(engineId: string, exportId: string): string;
+    protected getLink(engineId: string, exportId: UUID, params: MeasureExportParams): string;
     /**
      * Searches for measures and return them in a standard JSON
      */
-    search(digitalTwinId: string, { size, from, endAt, startAt, query, sort, type, }: ExportOptions): Promise<{
-        measures: import("kuzzle").KHit<MeasureContent<any, any>>[];
+    search(engineId: string, params: MeasureSearchParams, options?: MeasuresSearchOptions): Promise<{
+        measures: KHit<MeasureContent<any, any>>[];
         total: number;
     }>;
     /**
@@ -43,20 +37,16 @@ export declare class MeasureExporter {
      *
      * Never return a rejected promise and write potential error on the stream
      */
-    prepareExport(user: User, digitalTwinId: string, { endAt, startAt, query, sort, type, }: ExportOptions): Promise<{
-        link: string;
-    }>;
+    prepareExport(engineId: string, user: User, params: MeasureSearchParams): Promise<string>;
+    protected formatHit(columns: Column[], hit: KHit<MeasureContent>): any[];
     /**
      * Retrieve a prepared export and write each document as a CSV in the stream
      *
      * This method never returns a rejected promise, but write potential error in
      * the stream.
      */
-    sendExport(stream: PassThrough, exportId: string): Promise<void>;
+    sendExport(engineId: string, exportId: string): Promise<import("stream").PassThrough>;
     private generateMeasureColumns;
-    getExport(exportId: string): Promise<ExportParams>;
-    private exportRedisKey;
     private prepareMeasureSearch;
-    private getEngine;
 }
 export {};

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

@@ -1,3 +1,4 @@
+export * from "./services";
 export * from "./Module";
 export * from "./types/DigitalTwinContent";
 export * from "./types/Metadata";

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

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { UUID } from "node:crypto";
+import { PassThrough, Readable } from "node:stream";
+import { JSONObject, KDocumentContentGeneric, KHit, SearchResult, User } from "kuzzle";
+import { EngineContent } from "kuzzle-plugin-commons";
+import { DeviceManagerPlugin, InternalCollection } from "../../plugin";
+export interface ExporterOption {
+    /**
+     * Expiration time of export in seconds before being invalid
+     */
+    expireTime: number;
+}
+export interface ExportParams {
+    query: JSONObject;
+    sort?: JSONObject;
+    lang?: "elasticsearch" | "koncorde";
+}
+export interface Column {
+    header: string;
+    path: string;
+    isMeasure?: boolean;
+}
+export declare abstract class AbstractExporter<P extends ExportParams = ExportParams> {
+    protected plugin: DeviceManagerPlugin;
+    protected target: InternalCollection;
+    protected config: ExporterOption;
+    constructor(plugin: DeviceManagerPlugin, target: InternalCollection, config?: Partial<ExporterOption>);
+    protected get sdk(): import("kuzzle").EmbeddedSDK;
+    protected get ms(): any;
+    protected get 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;
+    };
+    protected getEngine(engineId: string): Promise<EngineContent>;
+    protected abstract exportRedisKey(engineId: string, exportId: string): string;
+    protected abstract getLink(engineId: string, exportId: UUID, params: P): string;
+    /**
+     * Retrieve a prepared export and write each document as a CSV in the stream
+     *
+     * This method never returns a rejected promise, but write potential error in
+     * the stream.
+     */
+    abstract sendExport(engineId: string, exportId: string): Promise<Readable>;
+    prepareExport(engineId: string, user: User, params: P): Promise<string>;
+    protected formatHit(columns: Column[], hit: KHit<KDocumentContentGeneric>): string[];
+    getExport(engineId: string, exportId: string): Promise<P>;
+    getExportStream(request: SearchResult<KHit<KDocumentContentGeneric>>, columns: Column[]): Promise<PassThrough>;
+}

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

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { UUID } from "node:crypto";
+import { AbstractExporter } from "./AbstractExporter";
+export declare class DigitalTwinExporter extends AbstractExporter {
+    protected exportRedisKey(engineId: string, exportId: string): string;
+    protected getLink(engineId: string, exportId: UUID): string;
+    sendExport(engineId: string, exportId: string): Promise<import("stream").PassThrough>;
+    /**
+     * Get the deduplicated Named Measures get from models
+     */
+    private getNamedMeasures;
+    private generateMeasureColumns;
+}

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

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

package/dist/lib/modules/shared/types/DigitalTwinContent.d.ts

@@ -8,4 +8,5 @@ export interface DigitalTwinContent<TMeasures extends JSONObject = JSONObject, T
     measures: {
         [Property in keyof TMeasures]: EmbeddedMeasure<TMeasures[Property]> | null;
     };
+    lastMeasuredAt: number;
 }

package/dist/tests/helpers/payloads.d.ts

@@ -0,0 +1,36 @@
+import { JSONObject, Kuzzle } from "kuzzle-sdk";
+type MeasureDated<T> = {
+    value: T;
+    measuredAt: number;
+};
+export type MeasureValue<T> = T | MeasureDated<T>;
+export declare function isMeasureDated<T>(measure: MeasureValue<T>): measure is MeasureDated<T>;
+export interface Location {
+    lat: number;
+    lon: number;
+    accuracy?: number;
+}
+export interface Acceleration {
+    x: number;
+    y: number;
+    z: number;
+    accuracy: number;
+}
+export type DummyTempSimplePayload = {
+    deviceEUI: string;
+    temperature: MeasureValue<number>;
+    measuredAt?: number;
+    battery?: MeasureValue<number>;
+    acceleration?: MeasureValue<Acceleration>;
+    metadata?: JSONObject;
+};
+export type DummyTempPayload = DummyTempSimplePayload | {
+    measurements: DummyTempSimplePayload[];
+};
+export type DummyTempPositionPayload = DummyTempPayload & {
+    location: MeasureValue<Location>;
+};
+export declare function sendDummyTempPayloads(sdk: Kuzzle, payloads: DummyTempPayload[]): Promise<void>;
+export declare function sendDummyTempPositionPayloads(sdk: Kuzzle, payloads: DummyTempPositionPayload[]): Promise<void>;
+export declare function sendPayloads(sdk: Kuzzle, action: string, payloads: JSONObject[]): Promise<any>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kuzzle-device-manager-types",
-  "version": "2.3.2",
+  "version": "2.4.0-beta.1-2",
   "description": "Shared types for Kuzzle Device Manager",
   "author": "The Kuzzle Team (support@kuzzle.io)",
   "main": "index.js",
@@ -17,4 +17,4 @@
   "files": [
     "dist/**/*.d.ts"
   ]
-}
+}