kuzzle-device-manager-types 3.0.0-3-dev.23 → 3.0.0-3-dev.24

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

@@ -4,7 +4,7 @@ export declare class AssetModule extends Module {
     private assetService;
     private assetHistoryService;
     private assetController;
-    private logger;
+    private readonly logger;
     constructor(plugin: DeviceManagerPlugin);
-    init(): Promise<void>;
+    init(): void;
 }

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

@@ -64,4 +64,8 @@ export declare class AssetService extends DigitalTwinService {
      * and the engines of the model tenantClasses otherwise.
      */
     private getModelEngines;
+    /**
+     * The reference is part of the asset id
+     */
+    private checkReference;
 }

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

@@ -28,7 +28,7 @@ export declare class AssetsController {
      * @param indexId The asset index
      * @param assetId The target asset ID
      * @param measureName The measureName to get the type from
-     * @param tenantClass The target tenant class
+     * @param request The ingestion request, whose user must see the asset
      * @returns The measure type if used in the asset, null otherwise
      * @throws If the asset does not exists
      */

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

@@ -12,5 +12,5 @@ export declare class DecoderModule extends Module {
     readonly payloadLogger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin);
     private get decodersRegister();
-    init(): Promise<void>;
+    init(): void;
 }

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

@@ -4,8 +4,8 @@ import { PayloadService } from "./PayloadService";
 import { ApiDecoderListResult, ApiDecoderPrunePayloadsResult } from "./types/DecoderApi";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class DecodersController {
-    private payloadService;
-    private decodersRegister;
+    private readonly payloadService;
+    private readonly decodersRegister;
     definition: ControllerDefinition;
     readonly logger: KuzzleLogger;
     constructor(payloadService: PayloadService, decodersRegister: DecodersRegister, logger: KuzzleLogger);

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

@@ -9,7 +9,7 @@ export declare class DecodersRegister {
     /**
      * Map<deviceModel, Decoder>
      */
-    private _decoders;
+    private readonly _decoders;
     private get sdk();
     get decoders(): Decoder[];
     init(plugin: DeviceManagerPlugin, context: PluginContext): void;

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

@@ -8,7 +8,7 @@ import { Decoder } from "./Decoder";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class PayloadService extends BaseService {
     readonly logger: KuzzleLogger;
-    private provisioningStrategy;
+    private readonly provisioningStrategy;
     constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
     /**
      * Process a payload by validating and decode it with the `decoder` associated
@@ -22,6 +22,12 @@ export declare class PayloadService extends BaseService {
     receiveFormated(device: KDocument<DeviceContent>, measurements: DecodedMeasurement[], { payloadUuids }?: {
         payloadUuids?: string[];
     }): Promise<void>;
+    private ingestDecodedDevice;
+    /**
+     * Ingest measurements of a device attached to an engine: measures linked to
+     * an asset go to that asset, the remaining ones to the device only.
+     */
+    private ingestEngineMeasurements;
     /**
      * Method used to save the payload and catch + log the error if any.
      *

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

@@ -4,8 +4,8 @@ import { PayloadService } from "./PayloadService";
 import { ApiPayloadReceiveUnkownResult } from "./types/PayloadApi";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class PayloadsController {
-    private payloadService;
-    private decodersRegister;
+    private readonly payloadService;
+    private readonly decodersRegister;
     readonly logger: KuzzleLogger;
     definition: ControllerDefinition;
     constructor(payloadService: PayloadService, decodersRegister: DecodersRegister, logger: KuzzleLogger);

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

@@ -6,5 +6,5 @@ export declare class DeviceModule extends Module {
     private deviceController;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin);
-    init(): Promise<void>;
+    init(): void;
 }

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

@@ -59,9 +59,16 @@ export declare class DeviceService extends DigitalTwinService {
      * @param {string} deviceId Id of the device
      * @param {KuzzleRequest} request kuzzle request
      */
-    detachEngine(deviceId: string, request: KuzzleRequest): Promise<KDocument<DeviceProvisioningContent>>;
+    detachEngine(deviceId: string, request: KuzzleRequest, { checkRights }?: {
+        checkRights?: boolean;
+    }): Promise<KDocument<DeviceProvisioningContent>>;
+    private _removeDeviceFromAssetLinks;
     receiveMeasures(index: string, deviceId: string, measures: DecodedMeasurement[], payloadUuids: string[], request: KuzzleRequest): Promise<void>;
     private checkEngineExists;
+    /**
+     * The reference is part of the device id, which is used in the API routes
+     */
+    private checkReference;
     private checkAttachedToEngine;
     private refreshModel;
 }

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

@@ -4,11 +4,11 @@ import { DeviceService } from "./DeviceService";
 import { ApiDeviceAttachEngineResult, ApiDeviceCreateResult, ApiDeviceDeleteResult, ApiDeviceDetachEngineResult, ApiDeviceGetResult, ApiDeviceLinkAssetsResult, ApiDeviceSearchResult, ApiDeviceUnlinkAssetsResult, ApiDeviceUpdateResult, ApiDeviceGetMeasuresResult, ApiDeviceUpsertResult, ApiDeviceGetLastMeasuresResult, ApiDeviceMGetLastMeasuresResult, ApiDeviceGetLastMeasuredAtResult, ApiDeviceMGetLastMeasuredAtResult, ApiDeviceMetadataReplaceResult, ApiDeviceUpdateMeasureSlotDisplayNameResult } from "./types/DeviceApi";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class DevicesController {
-    private plugin;
-    private deviceService;
+    private readonly plugin;
+    private readonly deviceService;
     definition: ControllerDefinition;
-    private exporter;
-    private measureExporter;
+    private readonly exporter;
+    private readonly measureExporter;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, deviceService: DeviceService, logger: KuzzleLogger);
     get(request: KuzzleRequest): Promise<ApiDeviceGetResult>;

package/dist/lib/modules/group/GroupsController.d.ts

@@ -4,8 +4,8 @@ import { ApiGroupAddAssetsResult, ApiGroupAddDevicesResult, ApiGroupCreateResult
 import { GroupsService } from "./GroupsService";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class GroupsController {
-    private plugin;
-    private groupsService;
+    private readonly plugin;
+    private readonly groupsService;
     definition: ControllerDefinition;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin, groupsService: GroupsService, logger: KuzzleLogger);
@@ -19,7 +19,7 @@ export declare class GroupsController {
      * @returns {void}
      */
     checkPath(index: string, path: GroupsBodyRequest["path"], groupId?: string): Promise<void>;
-    checkGroupName(index: string, name: GroupsBodyRequest["name"], assetId?: string): Promise<void>;
+    checkGroupName(index: string, name: GroupsBodyRequest["name"], groupId?: string): Promise<void>;
     create(request: KuzzleRequest): Promise<ApiGroupCreateResult>;
     get(request: KuzzleRequest): Promise<ApiGroupGetResult>;
     upsert(request: KuzzleRequest): Promise<ApiGroupUpsertResult>;

package/dist/lib/modules/group/GroupsModule.d.ts

@@ -6,5 +6,5 @@ export declare class GroupsModule extends Module {
     private groupsService;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin);
-    init(): Promise<void>;
+    init(): void;
 }

package/dist/lib/modules/group/GroupsService.d.ts

@@ -17,6 +17,16 @@ export declare class GroupsService extends BaseService {
     create(_id: string, index: string, metadata: JSONObject, model: string, name: string, path: string, request: KuzzleRequest): Promise<KDocument<GroupContent>>;
     get(index: string, _id: string, request: KuzzleRequest): Promise<import("kuzzle").KDocument<GroupContent>>;
     update(request: KuzzleRequest, _id: string, index: string, name?: string, metadata?: Metadata): Promise<import("kuzzle").KDocument<GroupContent>>;
+    /**
+     * Fetches every document matching the query, the default search size (10)
+     * would miss documents
+     */
+    private _searchAll;
+    /**
+     * Makes the latest writes (e.g. items just added to a group) visible to
+     * the subtree searches
+     */
+    private _refreshGroupCollections;
     private _updatePath;
     moveGroup(index: string, _id: string, targetGroupId: string | null, request: KuzzleRequest): Promise<{
         group: KDocument<GroupContent>;
@@ -121,5 +131,7 @@ export declare class GroupsService extends BaseService {
         name: string;
         path: string;
     }>, request: KuzzleRequest): Promise<ApiGroupMUpsertResult>;
+    private buildGroupDocument;
+    private toGroupCreationError;
     private _update;
 }

package/dist/lib/modules/group/groupPath.d.ts

@@ -0,0 +1,23 @@
+import { JSONObject } from "kuzzle-sdk";
+/**
+ * Group paths are the ids of the ancestors joined by ".", so a plain string
+ * prefix would also match siblings sharing the same id start
+ * (e.g. "parent.quai-1" is a string prefix of "parent.quai-10").
+ * Subtree checks must always include the separator.
+ */
+export declare const GROUP_PATH_SEPARATOR = ".";
+/**
+ * Whether `path` is the group `groupPath` itself or one of its descendants
+ */
+export declare function isInSubtree(path: string, groupPath: string): boolean;
+/**
+ * Replaces the leading `oldPath` of a path of its subtree by `newPath`
+ */
+export declare function rebasePath(path: string, oldPath: string, newPath: string): string;
+/**
+ * Elasticsearch query matching the documents whose `field` (a keyword) is in
+ * the subtree of `groupPath`
+ */
+export declare function subtreeQuery(field: string, groupPath: string, { includeSelf }?: {
+    includeSelf?: boolean;
+}): JSONObject;

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

@@ -5,5 +5,5 @@ export declare class MeasureModule extends Module {
     private measureService;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin);
-    init(): Promise<void>;
+    init(): void;
 }

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

@@ -5,7 +5,7 @@ export interface MeasureValidationChunks {
     validationErrors: ErrorObject[];
 }
 export declare class MeasureValidationError extends KuzzleError {
-    private errors;
+    private readonly errors;
     constructor(message: string, errors: MeasureValidationChunks[], id?: string, code?: number);
     get name(): string;
     toJSON(): import("kuzzle").JSONObject;

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

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

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

@@ -1,6 +1,6 @@
 import { KuzzleError } from "kuzzle";
 export declare class MeasuresNamesDuplicatesError extends KuzzleError {
-    private duplicates;
+    private readonly duplicates;
     constructor(message: string, duplicates: string[], id?: string, code?: number);
     get name(): string;
     toJSON(): import("kuzzle").JSONObject;

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

@@ -6,5 +6,5 @@ export declare class ModelModule extends Module {
     private modelController;
     readonly logger: KuzzleLogger;
     constructor(plugin: DeviceManagerPlugin);
-    init(): Promise<void>;
+    init(): void;
 }

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

@@ -1,5 +1,8 @@
 import { ModelContent } from "./types/ModelContent";
 export declare class ModelSerializer {
     static id<T extends ModelContent>(type: string, model: T): string;
+    private static assetId;
+    private static groupId;
+    private static measureId;
     static title<T extends ModelContent>(type: string, model: T): string;
 }

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

@@ -39,6 +39,11 @@ export declare class ModelService extends BaseService {
     private checkModelsConflicts;
     private checkDefaultValues;
     private checkGroupAffinity;
+    private validateAssetModel;
+    /**
+     * Anti-shadowing: rejects the model if one with the same name exists at a different scope level
+     */
+    private checkAssetModelScope;
     writeAsset(tenantClasses: string[], model: string, metadataMappings: MetadataMappings, defaultMetadata: JSONObject, metadataDetails: MetadataDetails, metadataGroups: MetadataGroups, measures: NamedMeasures, tooltipModels: TooltipModels, locales: {
         [valueName: string]: LocaleDetails;
     }, indexes?: string[], icon?: string): Promise<KDocument<AssetModelContent>>;

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

@@ -3,7 +3,7 @@ import { ModelService } from "./ModelService";
 import { ApiModelWriteAssetResult, ApiModelWriteDeviceResult, ApiModelWriteMeasureResult, ApiModelUpdateAssetResult, ApiModelDeleteAssetResult, ApiModelDeleteDeviceResult, ApiModelDeleteMeasureResult, ApiModelListAssetsResult, ApiModelListDevicesResult, ApiModelListMeasuresResult, ApiModelGetAssetResult, ApiModelGetDeviceResult, ApiModelGetMeasureResult, ApiModelSearchAssetsResult, ApiModelSearchDevicesResult, ApiModelSearchMeasuresResult, ApiModelDeleteGroupResult, ApiModelGetGroupResult, ApiModelListGroupsResult, ApiModelSearchGroupsResult, ApiModelWriteGroupResult, ApiModelUpdateGroupResult, ApiModelUpdateDeviceResult, ApiModelGetMetadataReferentialResult, ApiModelWriteMetadataResult, ApiModelDeleteMetadataResult } from "./types/ModelApi";
 import { KuzzleLogger } from "kuzzle-logger";
 export declare class ModelsController {
-    private modelService;
+    private readonly modelService;
     definition: ControllerDefinition;
     readonly logger: KuzzleLogger;
     constructor(modelService: ModelService, logger: KuzzleLogger);
@@ -20,6 +20,7 @@ export declare class ModelsController {
     deleteGroup(request: KuzzleRequest): Promise<ApiModelDeleteGroupResult>;
     deleteMeasure(request: KuzzleRequest): Promise<ApiModelDeleteMeasureResult>;
     listAssets(request: KuzzleRequest): Promise<ApiModelListAssetsResult>;
+    private checkEngineAndTenantClasses;
     listDevices(request: KuzzleRequest): Promise<ApiModelListDevicesResult>;
     listGroups(request: KuzzleRequest): Promise<ApiModelListGroupsResult>;
     listMeasures(request: KuzzleRequest): Promise<ApiModelListMeasuresResult>;

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

@@ -6,11 +6,11 @@ import { JSONObject } from "kuzzle-sdk";
 export declare class ModelsRegister {
     private config;
     private context;
-    private assetModels;
-    private deviceModels;
-    private groupModels;
-    private measureModels;
-    private metadataReferential;
+    private readonly assetModels;
+    private readonly deviceModels;
+    private readonly groupModels;
+    private readonly measureModels;
+    private readonly metadataReferential;
     private logger;
     private get sdk();
     init(plugin: DeviceManagerPlugin): void;

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

@@ -1,5 +1,6 @@
 import { Backend, KDocumentContent, Plugin } from "kuzzle";
 import { AbstractEngine, ConfigManager, EngineContent } from "kuzzle-plugin-commons";
+import { JSONObject } from "kuzzle-sdk";
 import { AssetModelContent, DeviceModelContent, GroupModelContent, MeasureModelContent } from "../model";
 import { DeviceManagerPlugin } from "./DeviceManagerPlugin";
 import { DeviceManagerConfiguration } from "./types/DeviceManagerConfiguration";
@@ -55,6 +56,22 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     config: DeviceManagerConfiguration;
     get app(): Backend;
     constructor(plugin: Plugin, platformConfigManager: ConfigManager, engineConfigManager: ConfigManager);
+    private resolveModels;
+    /**
+     * Return conflicts of new twin models, first against the platform models,
+     * then against the models and the actual mappings of every engine
+     */
+    private getTwinUpdateConflicts;
+    /**
+     * Return conflicts of new twin models applicable to an engine, against the engine
+     * models and the actual mappings of its collection
+     */
+    private getEngineTwinConflicts;
+    /**
+     * Return conflicts of new group models, against the platform group models
+     * then against the actual mappings of every engine groups collection
+     */
+    private getGroupsUpdateConflicts;
     /**
      * Returns the actual metadata mappings of an engine collection
      *
@@ -113,10 +130,10 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
     getEngines(): Promise<EngineDocument[]>;
     updateMeasuresSchema(): Promise<void>;
     onCreate(index: string, tenantClass?: string): Promise<{
-        collections: any[];
+        collections: string[];
     }>;
     onUpdate(index: string, tenantClass?: string): Promise<{
-        collections: any[];
+        collections: InternalCollection[];
     }>;
     onDelete(index: string): Promise<{
         collections: InternalCollection[];
@@ -217,7 +234,7 @@ export declare class DeviceManagerEngine extends AbstractEngine<DeviceManagerPlu
      * @returns The complete ES mappings produced by merging models mappings
      */
     private getMeasuresMappings;
-    getAssetGroupsMappingFromDB(): Promise<any>;
+    getAssetGroupsMappingFromDB(): Promise<JSONObject>;
     /**
      * Retrieve a certain type of models associated to an engine
      *

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

@@ -3,5 +3,5 @@ export declare abstract class Module {
     protected plugin: DeviceManagerPlugin;
     protected get sdk(): import("kuzzle").EmbeddedSDK;
     constructor(plugin: DeviceManagerPlugin);
-    abstract init(): Promise<void>;
+    abstract init(): void;
 }

package/dist/lib/modules/shared/errors/SchemaValidationError.d.ts

@@ -1,7 +1,7 @@
 import { ErrorObject } from "ajv";
 import { KuzzleError } from "kuzzle";
 export declare class SchemaValidationError extends KuzzleError {
-    private schemaErrors;
+    private readonly schemaErrors;
     constructor(message: string, schemaErrors: ErrorObject[], id?: string, code?: number);
     get name(): string;
     toJSON(): import("kuzzle").JSONObject;

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

@@ -6,12 +6,25 @@ interface PayloadRequest {
 }
 export type SearchParams = ReturnType<KuzzleRequest["getSearchParams"]>;
 export declare abstract class BaseService {
-    private plugin;
+    private readonly plugin;
     constructor(plugin: DeviceManagerPlugin);
     protected get app(): Backend;
     protected get sdk(): EmbeddedSDK;
     protected get config(): DeviceManagerConfiguration;
     protected get impersonatedSdk(): (user: User) => EmbeddedSDK;
+    /**
+     * Tells whether the request user may run the request action on the given
+     * engine.
+     *
+     * Needed for actions without an index argument (e.g. detachEngine): Kuzzle
+     * ignores the index restrictions of the user profiles for them.
+     */
+    protected isAllowedOnEngine(index: string, request: KuzzleRequest): Promise<boolean>;
+    /**
+     * Throws if the request user may not run the request action on the given
+     * engine.
+     */
+    protected checkEngineRights(index: string, request: KuzzleRequest): Promise<void>;
     /**
      * Returns a request of its own for a document operation: the
      * generic:document events see the index and collection written to, while

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

@@ -1,14 +1,23 @@
 /// <reference types="node" />
 /// <reference types="node" />
+import { KuzzleRequest, User } from "kuzzle";
 import { UUID } from "node:crypto";
 import { DeviceManagerPlugin, InternalCollection } from "../../plugin";
-import { AbstractExporter, ExporterOption } from "./AbstractExporter";
+import { AbstractExporter, ExporterOption, ExportParams } from "./AbstractExporter";
 export declare class DigitalTwinExporter extends AbstractExporter {
     protected plugin: DeviceManagerPlugin;
     protected target: InternalCollection;
     constructor(plugin: DeviceManagerPlugin, target: InternalCollection, config?: Partial<ExporterOption>);
     protected exportRedisKey(index: string, exportId: string): string;
     protected getLink(index: string, exportId: UUID): string;
+    /**
+     * Prepare an export of the digital twins matching the search.
+     *
+     * The search goes through the same "generic:document:beforeSearch" pipe as the
+     * search action of the request controller, so the export only contains the
+     * digital twins the user can search.
+     */
+    prepareExport(index: string, user: User, params: ExportParams, request?: KuzzleRequest): Promise<string>;
     sendExport(index: string, exportId: string): Promise<import("stream").PassThrough>;
     /**
      * Get the deduplicated Named Measures get from models

package/package.json

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