kuzzle-device-manager 3.0.0-3-dev.20 → 3.0.0-3-dev.21

package/dist/lib/modules/model/ModelService.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelService = void 0;
 const kuzzle_1 = require("kuzzle");
@@ -11,6 +14,8 @@ const AJValidator_1 = require("../shared/utils/AJValidator");
 const SchemaValidationError_1 = require("../shared/errors/SchemaValidationError");
 const MeasuresDuplicates_1 = require("./MeasuresDuplicates");
 const MeasuresNamesDuplicatesError_1 = require("./MeasuresNamesDuplicatesError");
+const lodash_1 = __importDefault(require("lodash"));
+const MetadataReferential_1 = require("./MetadataReferential");
 class ModelService extends shared_1.BaseService {
     constructor(plugin, logger) {
         super(plugin);
@@ -30,6 +35,7 @@ class ModelService extends shared_1.BaseService {
             const groupModel = await this.getGroup(model);
             return groupModel._source;
         });
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:metadata-referential:get", async () => this.getMetadataReferential());
         (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:measure:get", async ({ type, index }) => {
             const measureModel = await this.getMeasure(type, index);
             return measureModel._source;
@@ -156,157 +162,177 @@ class ModelService extends shared_1.BaseService {
         return { models, strict, type };
     }
     async writeAsset(tenantClasses, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, indexes, icon) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
-        }
-        if (indexes?.length && tenantClasses?.length) {
-            throw new kuzzle_1.BadRequestError(`"indexes" and "tenantClasses" are mutually exclusive on an asset model.`);
-        }
-        const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
-        if (duplicates.length > 0) {
-            throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Asset model measures contain one or multiple duplicate measure name", duplicates);
-        }
-        const normalizedTenantClasses = tenantClasses.includes("commons")
-            ? ["commons"]
-            : tenantClasses;
-        // Anti-shadowing: reject if a model with the same name exists at a different scope level
-        const isGlobal = normalizedTenantClasses.includes("commons") &&
-            (!indexes || indexes.length === 0);
-        const isTenantScoped = indexes && indexes.length > 0;
-        const isGroupScoped = !isGlobal && !isTenantScoped;
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        const existing = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
-            query: {
-                bool: {
-                    must: [
-                        { term: { type: "asset" } },
-                        { term: { "asset.model": model } },
-                    ],
-                },
-            },
-        }, { size: 10 });
-        for (const hit of existing.hits) {
-            const doc = hit._source;
-            const docIsGlobal = doc.tenantClasses?.includes("commons") &&
-                (!doc.indexes || doc.indexes.length === 0);
-            const docIsTenantScoped = doc.indexes && doc.indexes.length > 0;
-            const docIsGroupScoped = !docIsGlobal && !docIsTenantScoped;
-            // Same scope level: allow overwrite
-            if (isGlobal && docIsGlobal) {
-                continue;
-            }
-            if (isTenantScoped && docIsTenantScoped) {
-                continue;
-            }
-            if (isGroupScoped && docIsGroupScoped) {
-                continue;
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
             }
-            // Different scope levels: reject
-            if (docIsGlobal) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists as a global (commons) model. A model cannot exist at multiple scopes.`);
+            if (indexes?.length && tenantClasses?.length) {
+                throw new kuzzle_1.BadRequestError(`"indexes" and "tenantClasses" are mutually exclusive on an asset model.`);
             }
-            if (isGlobal) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at a non-global scope. A model cannot exist at multiple scopes.`);
+            const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
+            if (duplicates.length > 0) {
+                throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Asset model measures contain one or multiple duplicate measure name", duplicates);
             }
-            if (isTenantScoped && docIsGroupScoped) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at group scope. A model cannot be both group-scoped and tenant-scoped.`);
+            const normalizedTenantClasses = tenantClasses.includes("commons")
+                ? ["commons"]
+                : tenantClasses;
+            // Anti-shadowing: reject if a model with the same name exists at a different scope level
+            const isGlobal = normalizedTenantClasses.includes("commons") &&
+                (!indexes || indexes.length === 0);
+            const isTenantScoped = indexes && indexes.length > 0;
+            const isGroupScoped = !isGlobal && !isTenantScoped;
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            const existing = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
+                query: {
+                    bool: {
+                        must: [
+                            { term: { type: "asset" } },
+                            { term: { "asset.model": model } },
+                        ],
+                    },
+                },
+            }, { size: 10 });
+            for (const hit of existing.hits) {
+                const doc = hit._source;
+                const docIsGlobal = doc.tenantClasses?.includes("commons") &&
+                    (!doc.indexes || doc.indexes.length === 0);
+                const docIsTenantScoped = doc.indexes && doc.indexes.length > 0;
+                const docIsGroupScoped = !docIsGlobal && !docIsTenantScoped;
+                // Same scope level: allow overwrite
+                if (isGlobal && docIsGlobal) {
+                    continue;
+                }
+                if (isTenantScoped && docIsTenantScoped) {
+                    continue;
+                }
+                if (isGroupScoped && docIsGroupScoped) {
+                    continue;
+                }
+                // Different scope levels: reject
+                if (docIsGlobal) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists as a global (commons) model. A model cannot exist at multiple scopes.`);
+                }
+                if (isGlobal) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at a non-global scope. A model cannot exist at multiple scopes.`);
+                }
+                if (isTenantScoped && docIsGroupScoped) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at group scope. A model cannot be both group-scoped and tenant-scoped.`);
+                }
+                if (isGroupScoped && docIsTenantScoped) {
+                    throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at tenant scope. A model cannot be both group-scoped and tenant-scoped.`);
+                }
             }
-            if (isGroupScoped && docIsTenantScoped) {
-                throw new kuzzle_1.BadRequestError(`Asset model "${model}" already exists at tenant scope. A model cannot be both group-scoped and tenant-scoped.`);
+            const { fields: metadata, resolvedMappings } = await this.resolveMetadata("asset", model, { defaultMetadata, metadataDetails, metadataMappings });
+            const modelContent = {
+                asset: {
+                    ...metadata,
+                    icon,
+                    locales,
+                    measures,
+                    metadataGroups,
+                    model,
+                    tooltipModels,
+                },
+                ...(indexes?.length
+                    ? { indexes }
+                    : { tenantClasses: normalizedTenantClasses }),
+                type: "asset",
+            };
+            const modelId = ModelSerializer_1.ModelSerializer.id("asset", modelContent);
+            const stored = await this.getStoredModel(modelId);
+            this.checkReferentialOnly("asset", model, metadataMappings, stored);
+            this.checkDefaultValues(resolvedMappings, metadata.defaultMetadata);
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "asset" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`New assets mappings are causing conflicts`, conflicts);
             }
-        }
-        const modelContent = {
-            asset: {
-                defaultMetadata,
-                icon,
-                locales,
-                measures,
-                metadataDetails,
-                metadataGroups,
-                metadataMappings,
-                model,
-                tooltipModels,
-            },
-            ...(indexes?.length
-                ? { indexes }
-                : { tenantClasses: normalizedTenantClasses }),
-            type: "asset",
-        };
-        this.checkDefaultValues(metadataMappings, defaultMetadata);
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "asset" } });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`New assets mappings are causing conflicts`, conflicts);
-        }
-        const assetModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("asset", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
-            assetModel: assetModel._source,
+            const assetModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("asset", modelContent), modelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(modelId, stored);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
+                assetModel: assetModel._source,
+            });
+            return assetModel;
         });
-        return assetModel;
     }
     async writeDevice(model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, icon) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Device model "${model}" must be PascalCase.`);
-        }
-        const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
-        if (duplicates.length > 0) {
-            throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Device model measures contain one or multiple duplicate measure name", duplicates);
-        }
-        const modelContent = {
-            device: {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Device model "${model}" must be PascalCase.`);
+            }
+            const duplicates = (0, MeasuresDuplicates_1.getNamedMeasuresDuplicates)(measures);
+            if (duplicates.length > 0) {
+                throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Device model measures contain one or multiple duplicate measure name", duplicates);
+            }
+            const { fields: metadata } = await this.resolveMetadata("device", model, {
                 defaultMetadata,
-                icon,
-                measures,
                 metadataDetails,
-                metadataGroups,
                 metadataMappings,
-                model,
-            },
-            type: "device",
-        };
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "device" } });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`New devices mappings are causing conflicts`, conflicts);
-        }
-        const deviceModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("device", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:device:refresh-model", {
-            deviceModel: modelContent,
+            });
+            const modelContent = {
+                device: {
+                    ...metadata,
+                    icon,
+                    measures,
+                    metadataGroups,
+                    model,
+                },
+                type: "device",
+            };
+            const modelId = ModelSerializer_1.ModelSerializer.id("device", modelContent);
+            const stored = await this.getStoredModel(modelId);
+            this.checkReferentialOnly("device", model, metadataMappings, stored);
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [modelContent], type: "device" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`New devices mappings are causing conflicts`, conflicts);
+            }
+            const deviceModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("device", modelContent), modelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(modelId, stored);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:device:refresh-model", {
+                deviceModel: modelContent,
+            });
+            return deviceModel;
         });
-        return deviceModel;
     }
     async writeGroup(tenantClasses, model, affinity, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, icon, locales) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
-        }
-        if (tenantClasses.includes("commons")) {
-            tenantClasses = ["commons"];
-        }
-        const groupAffinity = this.checkGroupAffinity(affinity);
-        const modelContent = {
-            tenantClasses,
-            group: {
-                affinity: groupAffinity,
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
+            }
+            if (tenantClasses.includes("commons")) {
+                tenantClasses = ["commons"];
+            }
+            const groupAffinity = this.checkGroupAffinity(affinity);
+            const { fields: metadata } = await this.resolveMetadata("group", model, {
                 defaultMetadata,
-                icon,
-                locales,
                 metadataDetails,
-                metadataGroups,
                 metadataMappings,
-                model,
-            },
-            type: "group",
-        };
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { groupModels: [modelContent] });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`New group mappings are causing conflicts`, conflicts);
-        }
-        const groupModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("group", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-        return groupModel;
+            });
+            const modelContent = {
+                tenantClasses,
+                group: {
+                    ...metadata,
+                    affinity: groupAffinity,
+                    icon,
+                    locales,
+                    metadataGroups,
+                    model,
+                },
+                type: "group",
+            };
+            const modelId = ModelSerializer_1.ModelSerializer.id("group", modelContent);
+            const stored = await this.getStoredModel(modelId);
+            this.checkReferentialOnly("group", model, metadataMappings, stored);
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { groupModels: [modelContent] });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`New group mappings are causing conflicts`, conflicts);
+            }
+            const groupModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("group", modelContent), modelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(modelId, stored);
+            return groupModel;
+        });
     }
     async writeMeasure(type, valuesMappings, validationSchema, valuesDetails, locales, indexes, icon) {
         const modelContent = {
@@ -337,9 +363,11 @@ class ModelService extends shared_1.BaseService {
         if (conflicts.length > 0) {
             throw new MappingsConflictsError_1.MappingsConflictsError(`New assets mappings are causing conflicts`, conflicts);
         }
-        const measureModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("measure", modelContent), modelContent);
+        const modelId = ModelSerializer_1.ModelSerializer.id("measure", modelContent);
+        const stored = await this.getStoredModel(modelId);
+        const measureModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, modelId, modelContent);
         await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-        await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
+        await this.updateEnginesOrRestore(modelId, stored);
         return measureModel;
     }
     async deleteAsset(_id) {
@@ -737,60 +765,333 @@ class ModelService extends shared_1.BaseService {
      * Update an asset model
      */
     async updateAsset(tenantClasses, index, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, icon, request) {
-        if (kuzzle_1.Inflector.pascalCase(model) !== model) {
-            throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
-        }
-        this.checkDefaultValues(metadataMappings, defaultMetadata);
-        const existingAsset = await this.getAsset(tenantClasses, index, model);
-        // The field must be deleted if an element of the table is to be deleted
-        await this.sdk.document.deleteFields(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingAsset._id, [
-            "asset.tooltipModels",
-            "asset.metadataMappings",
-            "asset.defaultMetadata",
-            "asset.metadataDetails",
-            "asset.metadataGroups",
-        ], { source: true });
-        const measuresUpdated = measures.length === 0 ? existingAsset._source.asset.measures : measures;
-        // Preserve the existing scope: scope (tenantClasses / indexes) is decided
-        // at write time and must not be silently rewritten by an update payload.
-        // This also enforces tenantClasses / indexes mutual exclusivity (KZLPRD-1192).
-        const assetModelContent = {
-            asset: {
-                defaultMetadata,
-                icon: icon ?? existingAsset._source.asset.icon,
-                locales,
-                measures: measuresUpdated,
-                metadataDetails,
-                metadataGroups,
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
+            }
+            const existingAsset = await this.getAsset(tenantClasses, index, model);
+            this.checkReferentialOnly("asset", model, metadataMappings, existingAsset._source);
+            const { fields: metadata, resolvedMappings } = await this.resolveMetadata("asset", model, { defaultMetadata, metadataDetails, metadataMappings });
+            this.checkDefaultValues(resolvedMappings, metadata.defaultMetadata);
+            const measuresUpdated = measures.length === 0 ? existingAsset._source.asset.measures : measures;
+            // Preserve the existing scope: scope (tenantClasses / indexes) is decided
+            // at write time and must not be silently rewritten by an update payload.
+            // This also enforces tenantClasses / indexes mutual exclusivity (KZLPRD-1192).
+            const assetModelContent = {
+                asset: {
+                    ...metadata,
+                    icon: icon ?? existingAsset._source.asset.icon,
+                    locales,
+                    measures: measuresUpdated,
+                    metadataGroups,
+                    model,
+                    tooltipModels,
+                },
+                tenantClasses: existingAsset._source.tenantClasses,
+                indexes: existingAsset._source.indexes,
+                type: "asset",
+            };
+            const assetModel = {
+                _id: existingAsset._id,
+                _source: assetModelContent,
+            };
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [assetModelContent], type: "asset" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Assets mappings are causing conflicts`, conflicts);
+            }
+            // The field must be deleted if an element of the table is to be deleted.
+            // ? Only after the conflicts check, so a rejected update leaves the model untouched
+            await this.sdk.document.deleteFields(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingAsset._id, [
+                "asset.tooltipModels",
+                "asset.metadataMappings",
+                "asset.defaultMetadata",
+                "asset.metadataDetails",
+                "asset.metadataGroups",
+            ], { source: true });
+            const endDocument = await this.updateDocument(request, assetModel, {
+                collection: plugin_1.InternalCollection.MODELS,
+                index: this.config.platformIndex,
+            }, { source: true });
+            // ? Only update indexes and refresh asset models when necessary
+            if (Object.keys(metadata.metadataMappings).length > 0 ||
+                measures.length > 0) {
+                await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+                await this.updateEnginesOrRestore(existingAsset._id, existingAsset._source);
+                await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
+                    assetModel: endDocument._source,
+                });
+            }
+            return endDocument;
+        });
+    }
+    /**
+     * Adds metadata of the metadata referential to a device model.
+     *
+     * Device models are additive only from the API: every existing metadata must be kept unchanged,
+     * new metadata must come from the referential. Metadata details and default values can change.
+     * The engines mappings are updated and the devices get the new metadata with their default value.
+     *
+     * @throws BadRequestError if an existing metadata is missing or changed, or a new one is inline
+     * @throws MappingsConflictsError if the new metadata conflict with the existing mappings
+     */
+    async updateDevice(model, { defaultMetadata, metadataDetails, metadataMappings }) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            const existingDevice = await this.getDevice(model);
+            const existing = existingDevice._source.device;
+            const existingMappings = existing.metadataMappings ?? {};
+            const removed = Object.keys(existingMappings).filter((name) => !lodash_1.default.isEqual(existingMappings[name], metadataMappings[name]));
+            if (removed.length > 0) {
+                throw new kuzzle_1.BadRequestError(`Device model "${model}" metadata cannot be removed or modified: ${removed.join(", ")}`);
+            }
+            const inline = Object.keys(metadataMappings).filter((name) => !(name in existingMappings) &&
+                !(0, MetadataReferential_1.isReferentialMapping)(metadataMappings[name]));
+            if (inline.length > 0) {
+                throw new kuzzle_1.BadRequestError(`New metadata of device model "${model}" must come from the metadata referential, inline metadata: ${inline.join(", ")}`);
+            }
+            const { fields: metadata } = await this.resolveMetadata("device", model, {
+                defaultMetadata: defaultMetadata ?? existing.defaultMetadata,
+                metadataDetails: metadataDetails ?? existing.metadataDetails,
                 metadataMappings,
-                model,
-                tooltipModels,
+            });
+            const deviceModelContent = {
+                ...existingDevice._source,
+                device: { ...existing, ...metadata },
+            };
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [deviceModelContent], type: "device" } });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Devices mappings are causing conflicts`, conflicts);
+            }
+            const deviceModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingDevice._id, deviceModelContent);
+            await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
+            await this.updateEnginesOrRestore(existingDevice._id, existingDevice._source);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:device:refresh-model", { deviceModel: deviceModel._source });
+            return deviceModel;
+        });
+    }
+    /**
+     * Returns the group model available for the given tenant classes:
+     * a model of these classes first, then a commons model.
+     *
+     * @throws NotFoundError if no group model with this name is available
+     */
+    async getScopedGroup(tenantClasses, model) {
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
+            query: {
+                and: [
+                    { equals: { type: "group" } },
+                    { equals: { "group.model": model } },
+                ],
             },
-            tenantClasses: existingAsset._source.tenantClasses,
-            indexes: existingAsset._source.indexes,
-            type: "asset",
-        };
-        const assetModel = {
-            _id: existingAsset._id,
-            _source: assetModelContent,
-        };
-        const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { twin: { models: [assetModelContent], type: "asset" } });
-        if (conflicts.length > 0) {
-            throw new MappingsConflictsError_1.MappingsConflictsError(`Assets mappings are causing conflicts`, conflicts);
-        }
-        const endDocument = await this.updateDocument(request, assetModel, {
-            collection: plugin_1.InternalCollection.MODELS,
-            index: this.config.platformIndex,
-        }, { source: true });
-        // ? Only update indexes and refresh asset models when necessary
-        if (Object.keys(metadataMappings).length > 0 || measures.length > 0) {
+        }, { lang: "koncorde", size: 100 });
+        const scoped = result.hits.find(({ _source }) => _source.tenantClasses.some((tenantClass) => tenantClass !== "commons" && tenantClasses.includes(tenantClass)));
+        const common = result.hits.find(({ _source }) => _source.tenantClasses.includes("commons"));
+        const groupModel = scoped ?? common;
+        if (!groupModel) {
+            throw new kuzzle_1.NotFoundError(`Unknown Group model "${model}" for tenant classes "${tenantClasses.join(", ")}".`);
+        }
+        return { _id: groupModel._id, _source: groupModel._source };
+    }
+    /**
+     * Updates a group model, keeping its scope.
+     * Affinity and icon are kept when omitted.
+     *
+     * The engines mappings are updated and the groups of the model are refreshed.
+     *
+     * @throws MappingsConflictsError if the new mappings conflict with the existing ones
+     */
+    async updateGroup(tenantClasses, model, { affinity, defaultMetadata, icon, locales, metadataDetails, metadataGroups, metadataMappings, }) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            if (kuzzle_1.Inflector.pascalCase(model) !== model) {
+                throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
+            }
+            const existingGroup = await this.getScopedGroup(tenantClasses, model);
+            const existing = existingGroup._source.group;
+            this.checkReferentialOnly("group", model, metadataMappings, existingGroup._source);
+            const { fields: metadata, resolvedMappings } = await this.resolveMetadata("group", model, { defaultMetadata, metadataDetails, metadataMappings });
+            this.checkDefaultValues(resolvedMappings, metadata.defaultMetadata);
+            const groupModelContent = {
+                tenantClasses: existingGroup._source.tenantClasses,
+                group: {
+                    ...metadata,
+                    affinity: affinity === undefined
+                        ? existing.affinity
+                        : this.checkGroupAffinity(affinity),
+                    icon: icon ?? existing.icon,
+                    locales,
+                    metadataGroups,
+                    model,
+                },
+                type: "group",
+            };
+            const conflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesUpdateConflict", { groupModels: [groupModelContent] });
+            if (conflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Group mappings are causing conflicts`, conflicts);
+            }
+            const groupModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, existingGroup._id, groupModelContent);
             await this.sdk.collection.refresh(this.config.platformIndex, plugin_1.InternalCollection.MODELS);
-            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
-            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:asset:refresh-model", {
-                assetModel: endDocument._source,
+            await this.updateEnginesOrRestore(existingGroup._id, existingGroup._source);
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:group:refresh-model", {
+                groupModel: groupModel._source,
             });
+            return groupModel;
+        });
+    }
+    /**
+     * Validates the metadata of a model written through the API against the metadata referential
+     * and enriches the details and default values of the metadata coming from it
+     */
+    async resolveMetadata(modelType, model, fields) {
+        const enrichment = (0, MetadataReferential_1.enrichModelMetadata)(await this.getMetadataReferential(), fields, {
+            createError: (message) => new kuzzle_1.BadRequestError(message),
+            model,
+            modelType,
+        });
+        for (const warning of enrichment.warnings) {
+            this.logger.warn(warning);
+        }
+        return enrichment;
+    }
+    /**
+     * Resolves the referential metadata of stored models, to be returned by the API
+     */
+    async resolveModels(documents) {
+        const referential = await this.getMetadataReferential();
+        return documents.map((document) => ({
+            ...document,
+            _source: (0, MetadataReferential_1.resolveModelMetadata)(referential, document._source),
+        }));
+    }
+    async getMetadataReferential() {
+        return (0, MetadataReferential_1.fetchMetadataReferential)(this.sdk, this.config.platformIndex);
+    }
+    /**
+     * Creates a metadata of the metadata referential, or updates its details.
+     *
+     * The mappings of a new metadata are merged into the assets, devices and groups collections
+     * of every engine. They cannot be modified afterwards: only the locales, editor hint,
+     * default value and icon of an existing metadata can change. These are copied into the models
+     * using the metadata when they are written, the existing models are not modified.
+     *
+     * @throws BadRequestError if the mappings of an existing metadata are modified
+     * @throws MappingsConflictsError if the new metadata conflicts with an inline metadata of a model
+     *  or with the actual mappings of an engine collection
+     */
+    async writeMetadata(name, definition) {
+        (0, MetadataReferential_1.checkMetadataReferentialEntry)(name, definition, (message) => new kuzzle_1.BadRequestError(message));
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            const stored = await this.getMetadataReferential();
+            const entry = {
+                locales: {},
+                ...lodash_1.default.omit(definition, "managed"),
+            };
+            this.checkUnmanagedMetadata(stored, name);
+            if (stored[name]) {
+                if (!lodash_1.default.isEqual(stored[name].mappings, entry.mappings)) {
+                    throw new kuzzle_1.BadRequestError(`The mappings of metadata "${name}" cannot be modified, they are already merged into the engines collections`);
+                }
+                const referential = { ...stored, [name]: entry };
+                await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, referential);
+                return referential;
+            }
+            const models = await (0, MetadataReferential_1.fetchMetadataModels)(this.sdk, this.config.platformIndex);
+            const modelsConflicts = (0, MetadataReferential_1.getEntryModelsConflicts)(name, entry, models.map(({ _source }) => _source));
+            if (modelsConflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Metadata "${name}" conflicts with the metadata of models`, modelsConflicts);
+            }
+            const esConflicts = await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:doesMetadataConflict", { metadataMappings: { [name]: entry.mappings } });
+            if (esConflicts.length > 0) {
+                throw new MappingsConflictsError_1.MappingsConflictsError(`Metadata "${name}" conflicts with the engines collections mappings`, esConflicts);
+            }
+            const referential = { ...stored, [name]: entry };
+            await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, referential);
+            try {
+                await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
+            }
+            catch (error) {
+                // ? A metadata rejected by Elasticsearch would make every next engines update fail
+                await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, stored);
+                throw error;
+            }
+            return referential;
+        });
+    }
+    /**
+     * Deletes a metadata of the metadata referential.
+     * Its mappings stay in the engines collections, Elasticsearch cannot remove them.
+     *
+     * @throws BadRequestError if a model still uses the metadata
+     */
+    async deleteMetadata(name) {
+        return (0, MetadataReferential_1.withMetadataReferentialLock)(async () => {
+            const referential = await this.getMetadataReferential();
+            if (!referential[name]) {
+                throw new kuzzle_1.NotFoundError(`Unknown metadata "${name}" in the metadata referential`);
+            }
+            this.checkUnmanagedMetadata(referential, name);
+            const referencingModels = await (0, MetadataReferential_1.fetchReferencingModels)(this.sdk, this.config.platformIndex, name);
+            if (referencingModels.length > 0) {
+                throw new kuzzle_1.BadRequestError(`Metadata "${name}" is still used by the models: ${referencingModels
+                    .map(({ _id }) => _id)
+                    .join(", ")}`);
+            }
+            const updatedReferential = lodash_1.default.omit(referential, name);
+            await (0, MetadataReferential_1.saveMetadataReferential)(this.sdk, this.config.platformIndex, updatedReferential);
+            return updatedReferential;
+        });
+    }
+    /**
+     * With the referentialOnly option, rejects the inline metadata a model write adds.
+     * The inline metadata already defined by the stored model are kept (legacy).
+     *
+     * @throws BadRequestError if new inline metadata are added
+     */
+    checkReferentialOnly(modelType, model, metadataMappings, stored) {
+        if (!this.config.models?.metadata?.referentialOnly) {
+            return;
+        }
+        const added = (0, MetadataReferential_1.getAddedInlineMetadata)(metadataMappings, stored);
+        if (added.length > 0) {
+            throw new kuzzle_1.BadRequestError(`New metadata of ${modelType} model "${model}" must come from the metadata referential, inline metadata: ${added.join(", ")}`);
+        }
+    }
+    /**
+     * Updates the engines collections. If Elasticsearch rejects the new mappings, the model is
+     * restored to its previous version (or deleted if it is new), otherwise every next engines
+     * update would fail on it.
+     */
+    async updateEnginesOrRestore(_id, previous) {
+        try {
+            await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
+        }
+        catch (error) {
+            if (previous) {
+                await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id, lodash_1.default.omit(previous, "_kuzzle_info"), { refresh: "wait_for" });
+            }
+            else {
+                await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id, { refresh: "wait_for" });
+            }
+            throw error;
+        }
+    }
+    async getStoredModel(_id) {
+        try {
+            const { _source } = await this.sdk.document.get(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
+            return _source;
+        }
+        catch (error) {
+            if (error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * @throws BadRequestError if the metadata is registered from code
+     */
+    checkUnmanagedMetadata(referential, name) {
+        if (referential[name]?.managed) {
+            throw new kuzzle_1.BadRequestError(`Metadata "${name}" is registered from code, it cannot be modified or deleted through the API`);
         }
-        return endDocument;
     }
 }
 exports.ModelService = ModelService;