kuzzle-device-manager 2.11.0-dev.1 → 3.0.0-3-dev.1

package/dist/lib/modules/group/GroupsModule.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupsModule = void 0;
+const Module_1 = require("../shared/Module");
+const GroupsController_1 = require("./GroupsController");
+const GroupsService_1 = require("./GroupsService");
+const RoleGroupsAdmin_1 = require("./roles/RoleGroupsAdmin");
+const RoleGroupsReader_1 = require("./roles/RoleGroupsReader");
+class GroupsModule extends Module_1.Module {
+    constructor(plugin) {
+        super(plugin);
+        this.logger = this.plugin.context.logger.child("groups-module");
+    }
+    async init() {
+        this.groupsService = new GroupsService_1.GroupsService(this.plugin, this.logger);
+        this.groupsController = new GroupsController_1.GroupsController(this.plugin, this.groupsService, this.logger);
+        this.plugin.api["device-manager/groups"] = this.groupsController.definition;
+        this.plugin.imports.roles[RoleGroupsAdmin_1.RoleGroupsAdmin.name] =
+            RoleGroupsAdmin_1.RoleGroupsAdmin.definition;
+        this.plugin.imports.roles[RoleGroupsReader_1.RoleGroupsReader.name] =
+            RoleGroupsReader_1.RoleGroupsReader.definition;
+    }
+}
+exports.GroupsModule = GroupsModule;
+//# sourceMappingURL=GroupsModule.js.map

package/dist/lib/modules/group/GroupsModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GroupsModule.js","sourceRoot":"","sources":["../../../../lib/modules/group/GroupsModule.ts"],"names":[],"mappings":";;;AACA,6CAA0C;AAC1C,yDAAsD;AACtD,mDAAgD;AAChD,6DAA0D;AAC1D,+DAA4D;AAG5D,MAAa,YAAa,SAAQ,eAAM;IAKtC,YAAY,MAA2B;QACrC,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IAClE,CAAC;IACM,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,aAAa,GAAG,IAAI,6BAAa,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QACjE,IAAI,CAAC,gBAAgB,GAAG,IAAI,mCAAgB,CAC1C,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,aAAa,EAClB,IAAI,CAAC,MAAM,CACZ,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,uBAAuB,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC;QAE5E,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,iCAAe,CAAC,IAAI,CAAC;YAC7C,iCAAe,CAAC,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,mCAAgB,CAAC,IAAI,CAAC;YAC9C,mCAAgB,CAAC,UAAU,CAAC;IAChC,CAAC;CACF;AAxBD,oCAwBC"}

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

@@ -0,0 +1,118 @@
+import { JSONObject, KDocument } from "kuzzle-sdk";
+import { DeviceManagerPlugin } from "../plugin";
+import { BaseService, Metadata, SearchParams } from "../shared";
+import { KuzzleRequest } from "kuzzle";
+import { AssetContent } from "../asset/types/AssetContent";
+import { ApiGroupMCreateResult, ApiGroupMUpdateResult, ApiGroupMUpsertResult, GroupContent } from "./exports";
+import { DeviceContent } from "../device";
+import { KuzzleLogger } from "kuzzle-logger";
+export declare class GroupsService extends BaseService {
+    readonly logger: KuzzleLogger;
+    constructor(plugin: DeviceManagerPlugin, logger: KuzzleLogger);
+    create(_id: string, engineId: string, metadata: JSONObject, model: string, name: string, path: string, request: KuzzleRequest): Promise<KDocument<GroupContent>>;
+    get(engineId: string, _id: string, request: KuzzleRequest): Promise<import("kuzzle").KDocument<GroupContent>>;
+    update(request: KuzzleRequest, _id: string, engineId: string, name?: string, path?: string, metadata?: Metadata): Promise<import("kuzzle").KDocument<GroupContent>>;
+    delete(_id: string, engineId: string, request: KuzzleRequest): Promise<{
+        _id: string;
+    }>;
+    search(engineId: string, searchParams: SearchParams, request: KuzzleRequest): Promise<import("kuzzle").SearchResult<import("kuzzle").KHit<GroupContent>>>;
+    listItems(engineId: string, _id: string, includeChildren: boolean, options: {
+        from?: number;
+        size?: number;
+    }, request: KuzzleRequest): Promise<{
+        assets: {
+            hits: import("kuzzle").KHit<AssetContent<any>>[];
+            total: number;
+        };
+        devices: {
+            hits: import("kuzzle").KHit<DeviceContent<any>>[];
+            total: number;
+        };
+    }>;
+    addAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeAssets(engineId: string, path: string, assetIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    addDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    removeDevices(engineId: string, path: string, deviceIds: string[], request: KuzzleRequest): Promise<{
+        group: import("kuzzle").KDocument<GroupContent>;
+        successes: {
+            _id: string;
+            _source: import("kuzzle").JSONObject;
+            _version: number;
+        }[];
+        errors: {
+            document: {
+                _id: string;
+                body: import("kuzzle").JSONObject;
+            };
+            status: number;
+            reason: string;
+        }[];
+    }>;
+    mCreate(engineId: string, groups: Array<{
+        _id: string;
+        metadata: Metadata;
+        model: string;
+        name: string;
+        path: string;
+    }>): Promise<ApiGroupMCreateResult>;
+    mUpdate(engineId: string, groups: Array<{
+        _id: string;
+        metadata: Metadata;
+        model: string;
+        name: string;
+        path: string;
+    }>, request: KuzzleRequest): Promise<ApiGroupMUpdateResult>;
+    mUpsert(engineId: string, groups: Array<{
+        _id: string;
+        metadata: Metadata;
+        model: string;
+        name: string;
+        path: string;
+    }>, request: KuzzleRequest): Promise<ApiGroupMUpsertResult>;
+    private _update;
+}

package/dist/lib/modules/group/GroupsService.js

@@ -0,0 +1,518 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupsService = void 0;
+const plugin_1 = require("../plugin");
+const shared_1 = require("../shared");
+const kuzzle_1 = require("kuzzle");
+const kuzzle_plugin_commons_1 = require("kuzzle-plugin-commons");
+class GroupsService extends shared_1.BaseService {
+    constructor(plugin, logger) {
+        super(plugin);
+        this.logger = logger;
+    }
+    async create(_id, engineId, metadata, model, name, path, request) {
+        const groupMetadata = {};
+        if (model !== null) {
+            const groupModel = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:group:get", {
+                model,
+            });
+            for (const metadataName of Object.keys(groupModel.group.metadataMappings)) {
+                if (metadata[metadataName]) {
+                    groupMetadata[metadataName] = metadata[metadataName];
+                }
+                else if (groupModel.group.defaultMetadata[metadataName]) {
+                    groupMetadata[metadataName] =
+                        groupModel.group.defaultMetadata[metadataName];
+                }
+                else {
+                    groupMetadata[metadataName] = null;
+                }
+            }
+        }
+        const group = {
+            _id,
+            _source: {
+                lastUpdate: Date.now(),
+                metadata: { ...groupMetadata },
+                model,
+                name,
+                path,
+            },
+        };
+        return this.createDocument(request, group, {
+            collection: plugin_1.InternalCollection.GROUPS,
+            engineId,
+        });
+    }
+    async get(engineId, _id, request) {
+        return this.getDocument(request, _id, {
+            collection: plugin_1.InternalCollection.GROUPS,
+            engineId,
+        });
+    }
+    async update(request, _id, engineId, name, path, metadata) {
+        let updateRequestBody = {};
+        if (name !== undefined) {
+            updateRequestBody = { ...updateRequestBody, name };
+        }
+        if (path !== undefined) {
+            updateRequestBody = { ...updateRequestBody, path };
+        }
+        if (metadata !== undefined) {
+            const group = await this.get(engineId, _id, request);
+            const { model, metadata: groupMetadata } = group._source;
+            if (model !== null) {
+                const groupModel = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:group:get", {
+                    model,
+                });
+                for (const metadataName of Object.keys(groupModel.group.metadataMappings)) {
+                    if (metadata[metadataName] !== undefined) {
+                        groupMetadata[metadataName] = metadata[metadataName];
+                    }
+                }
+                updateRequestBody = { ...updateRequestBody, metadata: groupMetadata };
+            }
+        }
+        const groupToUpdate = await this.sdk.document.get(engineId, plugin_1.InternalCollection.GROUPS, _id);
+        const updatedGroup = await this._update(request, _id, engineId, updateRequestBody);
+        if (updatedGroup._source.path !== groupToUpdate._source.path) {
+            const { hits: assets } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.ASSETS, {
+                query: {
+                    prefix: {
+                        "groups.path": {
+                            value: groupToUpdate._source.path,
+                        },
+                    },
+                },
+            }, { lang: "koncorde" });
+            const { hits: devices } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.DEVICES, {
+                query: {
+                    prefix: {
+                        "groups.path": {
+                            value: groupToUpdate._source.path,
+                        },
+                    },
+                },
+            }, { lang: "koncorde" });
+            await this.sdk.document.mUpdate(engineId, plugin_1.InternalCollection.ASSETS, assets.map((asset) => ({
+                _id: asset._id,
+                body: {
+                    groups: asset._source.groups.map((grp) => {
+                        if (grp.path.includes(groupToUpdate._source.path)) {
+                            grp.path = grp.path.replace(groupToUpdate._source.path, updatedGroup._source.path);
+                            grp.date = Date.now();
+                        }
+                        return grp;
+                    }),
+                },
+            })), { strict: true });
+            await this.sdk.document.mUpdate(engineId, plugin_1.InternalCollection.DEVICES, devices.map((device) => ({
+                _id: device._id,
+                body: {
+                    groups: device._source.groups.map((grp) => {
+                        if (grp.path.includes(groupToUpdate._source.path)) {
+                            grp.path = grp.path.replace(groupToUpdate._source.path, updatedGroup._source.path);
+                            grp.date = Date.now();
+                        }
+                        return grp;
+                    }),
+                },
+            })), { strict: true });
+            const { hits: childrenGroups } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.GROUPS, {
+                query: {
+                    and: [
+                        {
+                            prefix: {
+                                path: {
+                                    value: groupToUpdate._source.path,
+                                },
+                            },
+                        },
+                        {
+                            not: { equals: { path: groupToUpdate._source.path } },
+                        },
+                    ],
+                },
+            }, { lang: "koncorde" });
+            await this.sdk.document.mUpdate(engineId, plugin_1.InternalCollection.GROUPS, childrenGroups.map((grp) => {
+                grp._source.path = grp._source.path.replace(groupToUpdate._source.path, updatedGroup._source.path);
+                grp._source.lastUpdate = Date.now();
+                return { _id: grp._id, body: grp._source };
+            }), { strict: true });
+        }
+        return updatedGroup;
+    }
+    async delete(_id, engineId, request) {
+        const group = await this.get(engineId, _id, request);
+        if (!group) {
+            throw new kuzzle_1.BadRequestError(`The group with id "${_id}" does not exist`);
+        }
+        const { hits: assets } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.ASSETS, {
+            query: {
+                prefix: {
+                    "groups.path": {
+                        value: group._source.path,
+                    },
+                },
+            },
+        }, { lang: "koncorde" });
+        await this.sdk.document.mUpdate(engineId, plugin_1.InternalCollection.ASSETS, assets.map((asset) => ({
+            _id: asset._id,
+            body: {
+                groups: asset._source.groups
+                    .filter((grp) => grp.path !== group._source.path)
+                    .map((grp) => {
+                    if (grp.path.includes(group._source.path)) {
+                        grp.path = grp.path.replace(`${group._source.path}.`, "");
+                        grp.date = Date.now();
+                    }
+                    return grp;
+                }),
+            },
+        })), { strict: true });
+        const { hits: devices } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.DEVICES, {
+            query: {
+                prefix: {
+                    "groups.path": {
+                        value: group._source.path,
+                    },
+                },
+            },
+        }, { lang: "koncorde" });
+        await this.sdk.document.mUpdate(engineId, plugin_1.InternalCollection.DEVICES, devices.map((device) => ({
+            _id: device._id,
+            body: {
+                groups: device._source.groups
+                    .filter((grp) => grp.path !== group._source.path)
+                    .map((grp) => {
+                    if (grp.path.includes(group._source.path)) {
+                        grp.path = grp.path.replace(`${group._source.path}.`, "");
+                        grp.date = Date.now();
+                    }
+                    return grp;
+                }),
+            },
+        })), { strict: true });
+        const { hits: childrenGroups } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.GROUPS, {
+            query: {
+                prefix: {
+                    path: {
+                        value: _id,
+                    },
+                },
+            },
+        }, { lang: "koncorde" });
+        await this.sdk.document.mUpdate(engineId, plugin_1.InternalCollection.GROUPS, childrenGroups.map((grp) => {
+            grp._source.path = grp._source.path.replace(`${group._source.path}.`, "");
+            grp._source.lastUpdate = Date.now();
+            return { _id: grp._id, body: grp._source };
+        }), { strict: true });
+        return this.deleteDocument(request, _id, {
+            collection: plugin_1.InternalCollection.GROUPS,
+            engineId,
+        });
+    }
+    async search(engineId, searchParams, request) {
+        return this.searchDocument(request, searchParams, {
+            collection: plugin_1.InternalCollection.GROUPS,
+            engineId,
+        });
+    }
+    async listItems(engineId, _id, includeChildren, options, request) {
+        const group = await this.get(engineId, _id, request);
+        if (!group) {
+            throw new kuzzle_1.BadRequestError(`The group with _id "${_id}" does not exist`);
+        }
+        const body = includeChildren
+            ? {
+                query: {
+                    prefix: {
+                        "groups.path": {
+                            value: group._source.path,
+                        },
+                    },
+                },
+            }
+            : {
+                query: {
+                    term: {
+                        "groups.path": group._source.path,
+                    },
+                },
+            };
+        const { hits: assetHits, total: assetTotal } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.ASSETS, body, options);
+        const { hits: deviceHits, total: deviceTotal } = await this.sdk.document.search(engineId, plugin_1.InternalCollection.DEVICES, body, options);
+        return {
+            assets: { hits: assetHits, total: assetTotal },
+            devices: { hits: deviceHits, total: deviceTotal },
+        };
+    }
+    async addAssets(engineId, path, assetIds, request) {
+        const _id = path.split(".").pop();
+        const group = await this.sdk.document.get(engineId, plugin_1.InternalCollection.GROUPS, _id);
+        if (!group) {
+            throw new kuzzle_1.BadRequestError(`The group with path "${path}" does not exist`);
+        }
+        let model;
+        if (group._source.model) {
+            model = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:group:get", {
+                model: group._source.model,
+            });
+        }
+        if (model && !model.group.affinity.type.includes("assets")) {
+            throw new kuzzle_1.BadRequestError(`The group ${group._id} of model ${group._source.model} can not contain assets`);
+        }
+        const { successes: assets, errors } = await this.sdk.document.mGet(engineId, plugin_1.InternalCollection.ASSETS, assetIds);
+        if (errors.length > 0) {
+            throw new kuzzle_1.BadRequestError(`The assets with ids "${errors.join(", ")}" do not exist`);
+        }
+        if (model && model.group.affinity.strict) {
+            for (const asset of assets) {
+                if (!model.group.affinity.models.assets.includes(asset._source.model)) {
+                    throw new kuzzle_1.BadRequestError(`Groups of model ${group._source.model} can not contain assets of model ${asset._source.model}`);
+                }
+            }
+        }
+        const assetsToUpdate = assets.map((asset) => {
+            if (!Array.isArray(asset._source.groups)) {
+                asset._source.groups = [];
+            }
+            if (!asset._source.groups.some((g) => g.path === path)) {
+                asset._source.groups.push({
+                    date: Date.now(),
+                    path: path,
+                });
+            }
+            return asset;
+        });
+        const groupUpdate = await this._update(request, _id, engineId, {
+            lastUpdate: Date.now(),
+        });
+        const refresh = request.getRefresh();
+        const update = await this.sdk.document.mReplace(engineId, plugin_1.InternalCollection.ASSETS, assetsToUpdate.map((asset) => ({ _id: asset._id, body: asset._source })), { refresh, triggerEvents: true });
+        return {
+            ...update,
+            group: groupUpdate,
+        };
+    }
+    async removeAssets(engineId, path, assetIds, request) {
+        const _id = path.split(".").pop();
+        if (!(await this.sdk.document.exists(engineId, plugin_1.InternalCollection.GROUPS, _id))) {
+            throw new kuzzle_1.BadRequestError(`The group with path "${path}" does not exist`);
+        }
+        const { successes: assets, errors } = await this.sdk.document.mGet(engineId, plugin_1.InternalCollection.ASSETS, assetIds);
+        if (errors.length > 0) {
+            throw new kuzzle_1.BadRequestError(`The assets with ids "${errors.join(", ")}" do not exist`);
+        }
+        const assetsToUpdate = assets.map((asset) => {
+            asset._source.groups = asset._source.groups.filter((grp) => grp.path !== path);
+            return asset;
+        });
+        const groupUpdate = await this._update(request, _id, engineId, {
+            lastUpdate: Date.now(),
+        });
+        const refresh = request.getRefresh();
+        const update = await this.sdk.document.mReplace(engineId, plugin_1.InternalCollection.ASSETS, assetsToUpdate.map((asset) => ({ _id: asset._id, body: asset._source })), { refresh, triggerEvents: true });
+        return {
+            ...update,
+            group: groupUpdate,
+        };
+    }
+    async addDevices(engineId, path, deviceIds, request) {
+        const _id = path.split(".").pop();
+        const group = await this.sdk.document.get(engineId, plugin_1.InternalCollection.GROUPS, _id);
+        if (!group) {
+            throw new kuzzle_1.BadRequestError(`The group with path "${path}" does not exist`);
+        }
+        let model;
+        if (group._source.model) {
+            model = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:group:get", {
+                model: group._source.model,
+            });
+        }
+        if (model && !model.group.affinity.type.includes("devices")) {
+            throw new kuzzle_1.BadRequestError(`The group ${group._id} of model ${group._source.model} can not contain devices`);
+        }
+        const { successes: devices, errors } = await this.sdk.document.mGet(engineId, plugin_1.InternalCollection.DEVICES, deviceIds);
+        if (errors.length > 0) {
+            throw new kuzzle_1.BadRequestError(`The devices with ids "${errors.join(", ")}" do not exist`);
+        }
+        if (model && model.group.affinity.strict) {
+            for (const device of devices) {
+                if (!model.group.affinity.models.devices.includes(device._source.model)) {
+                    throw new kuzzle_1.BadRequestError(`Groups of model ${group._source.model} can not contain devices of model ${device._source.model}`);
+                }
+            }
+        }
+        const devicesToUpdate = devices.map((device) => {
+            if (!Array.isArray(device._source.groups)) {
+                device._source.groups = [];
+            }
+            if (!device._source.groups.some((g) => g.path === path)) {
+                device._source.groups.push({
+                    date: Date.now(),
+                    path: path,
+                });
+            }
+            return device;
+        });
+        const groupUpdate = await this._update(request, _id, engineId, {
+            lastUpdate: Date.now(),
+        });
+        const refresh = request.getRefresh();
+        const update = await this.sdk.document.mReplace(engineId, plugin_1.InternalCollection.DEVICES, devicesToUpdate.map((device) => ({
+            _id: device._id,
+            body: device._source,
+        })), { refresh, triggerEvents: true });
+        return {
+            ...update,
+            group: groupUpdate,
+        };
+    }
+    async removeDevices(engineId, path, deviceIds, request) {
+        const _id = path.split(".").pop();
+        if (!(await this.sdk.document.exists(engineId, plugin_1.InternalCollection.GROUPS, _id))) {
+            throw new kuzzle_1.BadRequestError(`The group with path "${path}" does not exist`);
+        }
+        const { successes: devices, errors } = await this.sdk.document.mGet(engineId, plugin_1.InternalCollection.DEVICES, deviceIds);
+        if (errors.length > 0) {
+            throw new kuzzle_1.BadRequestError(`The devices with ids "${errors.join(", ")}" do not exist`);
+        }
+        const devicesToUpdate = devices.map((device) => {
+            device._source.groups = device._source.groups.filter((grp) => grp.path !== path);
+            return device;
+        });
+        const groupUpdate = await this._update(request, _id, engineId, {
+            lastUpdate: Date.now(),
+        });
+        const refresh = request.getRefresh();
+        const update = await this.sdk.document.mReplace(engineId, plugin_1.InternalCollection.DEVICES, devicesToUpdate.map((device) => ({
+            _id: device._id,
+            body: device._source,
+        })), { refresh, triggerEvents: true });
+        return {
+            ...update,
+            group: groupUpdate,
+        };
+    }
+    async mCreate(engineId, groups) {
+        const toCreate = [];
+        const toCreateErrors = [];
+        for (const g of groups) {
+            try {
+                const groupMetadata = {};
+                if (g.model !== null) {
+                    const groupModel = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:model:group:get", {
+                        model: g.model,
+                    });
+                    for (const metadataName of Object.keys(groupModel.group.metadataMappings)) {
+                        if (g.metadata[metadataName]) {
+                            groupMetadata[metadataName] = g.metadata[metadataName];
+                        }
+                        else if (groupModel.group.defaultMetadata[metadataName]) {
+                            groupMetadata[metadataName] =
+                                groupModel.group.defaultMetadata[metadataName];
+                        }
+                        else {
+                            groupMetadata[metadataName] = null;
+                        }
+                    }
+                }
+                toCreate.push({
+                    _id: g._id,
+                    body: {
+                        lastUpdate: Date.now(),
+                        metadata: { ...groupMetadata },
+                        model: g.model,
+                        name: g.name,
+                        path: g.path,
+                    },
+                });
+            }
+            catch (error) {
+                let reason = "";
+                let status = 400;
+                if (error instanceof kuzzle_1.KuzzleError) {
+                    reason = error.message;
+                    status = error.code;
+                }
+                toCreateErrors.push({
+                    document: {
+                        _id: g._id,
+                        body: {
+                            metadata: g.metadata,
+                            model: g.model,
+                            name: g.name,
+                            path: g.path,
+                        },
+                    },
+                    reason,
+                    status,
+                });
+            }
+        }
+        const { successes, errors } = await this.sdk.document.mCreate(engineId, plugin_1.InternalCollection.GROUPS, toCreate);
+        return {
+            errors: [...toCreateErrors, ...errors],
+            successes: successes,
+        };
+    }
+    async mUpdate(engineId, groups, request) {
+        const successes = [];
+        const errors = [];
+        await Promise.allSettled(groups.map((g) => this.update(request, g._id, engineId, g.name, g.path, g.metadata)
+            .then((u) => successes.push(u))
+            .catch((error) => {
+            const { _id, ...rest } = g;
+            let reason = "";
+            let status = 400;
+            if (error instanceof kuzzle_1.KuzzleError) {
+                reason = error.message;
+                status = error.code;
+            }
+            errors.push({
+                document: { _id, body: { ...rest } },
+                reason,
+                status,
+            });
+        })));
+        return {
+            errors,
+            successes,
+        };
+    }
+    async mUpsert(engineId, groups, request) {
+        const toUpdate = [];
+        const toCreate = [];
+        for (const g of groups) {
+            try {
+                await this.getDocument(request, g._id, {
+                    collection: plugin_1.InternalCollection.GROUPS,
+                    engineId,
+                });
+                toUpdate.push(g);
+            }
+            catch {
+                g.path = g.path ?? g._id;
+                if (!g.path.includes(g._id)) {
+                    g.path += `.${g._id}`;
+                }
+                toCreate.push(g);
+            }
+        }
+        const createdResult = await this.mCreate(engineId, toCreate);
+        const updatedResult = await this.mUpdate(engineId, toUpdate, request);
+        return {
+            errors: [...createdResult.errors, ...updatedResult.errors],
+            successes: [...createdResult.successes, ...updatedResult.successes],
+        };
+    }
+    async _update(request, _id, engineId, updateContent) {
+        return this.updateDocument(request, {
+            _id,
+            _source: { ...updateContent, lastUpdate: Date.now() },
+        }, { collection: plugin_1.InternalCollection.GROUPS, engineId }, { source: true, triggerEvents: true });
+    }
+}
+exports.GroupsService = GroupsService;
+//# sourceMappingURL=GroupsService.js.map