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

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

@@ -18,8 +18,8 @@ class ModelService extends shared_1.BaseService {
         this.registerAskEvents();
     }
     registerAskEvents() {
-        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:asset:get", async ({ engineGroup, model }) => {
-            const assetModel = await this.getAsset(engineGroup, model);
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:asset:get", async ({ engineGroups, engineId, model }) => {
+            const assetModel = await this.getAsset(engineGroups, engineId, model);
             return assetModel._source;
         });
         (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:device:get", async ({ model }) => {
@@ -30,13 +30,13 @@ 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:measure:get", async ({ type }) => {
-            const measureModel = await this.getMeasure(type);
+        (0, kuzzle_plugin_commons_1.onAsk)("ask:device-manager:model:measure:get", async ({ type, engineId }) => {
+            const measureModel = await this.getMeasure(type, engineId);
             return measureModel._source;
         });
         const genericModelsHandler = async (documents, request) => {
             const { index, collection } = request.input.args;
-            if (index === this.config.adminIndex && collection === "models") {
+            if (index === this.config.platformIndex && collection === "models") {
                 const models = documents.map((elt) => {
                     return elt._source;
                 });
@@ -48,7 +48,7 @@ class ModelService extends shared_1.BaseService {
         this.app.pipe.register("generic:document:beforeUpdate", genericModelsHandler);
         this.app.hook.register("generic:document:afterUpdate", async (documents, request) => {
             const { index, collection } = request.input.args;
-            if (index === this.config.adminIndex && collection === "models") {
+            if (index === this.config.platformIndex && collection === "models") {
                 await (0, kuzzle_plugin_commons_1.ask)("ask:device-manager:engine:updateAll");
             }
         });
@@ -105,7 +105,57 @@ class ModelService extends shared_1.BaseService {
             }
         }
     }
-    async writeAsset(engineGroup, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales) {
+    checkDefaultValues(metadataMappings, defaultMetadata) {
+        const flattenedMetadataMappings = (0, shared_1.flattenObject)(metadataMappings);
+        const metadata = Object.keys(JSON.parse(JSON.stringify(flattenedMetadataMappings)
+            .replace(/properties\./g, "")
+            .replace(/\.type/g, "")));
+        const values = Object.keys((0, shared_1.flattenObject)(defaultMetadata));
+        for (let i = 0; i < values.length; i++) {
+            const key = values[i];
+            // ? Check if the exact key exists in the metadata
+            if (!metadata.includes(key)) {
+                // ? Extract base key for complex types like geo_point or geo_shape
+                const baseKey = key.includes(".") ? key.split(".")[0] : key;
+                // ? Check if the base key is in the metadata
+                if (!metadata.includes(baseKey)) {
+                    throw new kuzzle_1.BadRequestError(`The default value "${key}" is not in the metadata mappings.`);
+                }
+                // ? Accept nested properties for geo_point or geo_shape
+                const baseKeyMetadata = flattenedMetadataMappings[`${baseKey}.type`];
+                if (baseKeyMetadata === "geo_point" ||
+                    baseKeyMetadata === "geo_shape") {
+                    continue;
+                }
+                throw new kuzzle_1.BadRequestError(`The default value "${values[i]}" is not in the metadata mappings.`);
+            }
+        }
+    }
+    checkGroupAffinity(affinity) {
+        const { type, strict, models } = affinity;
+        if (!type || strict === undefined || !models) {
+            throw new kuzzle_1.BadRequestError(`The group affinity must specify a type array, models and strictness`);
+        }
+        if (!Array.isArray(type) ||
+            type.length > 2 ||
+            type.length < 1 ||
+            !type.every((t) => ["assets", "devices"].includes(t))) {
+            throw new kuzzle_1.BadRequestError(`The group type must be an array containing "assets" and/or "devices"`);
+        }
+        if (typeof strict !== "boolean") {
+            throw new kuzzle_1.BadRequestError(`The group affinity strict field must be a boolean`);
+        }
+        for (const t of type) {
+            if (!models[t] || !Array.isArray(models[t])) {
+                throw new kuzzle_1.BadRequestError(`The group affinity must contain an array for every present type`);
+            }
+            if (!models[t].every((model) => typeof model === "string")) {
+                throw new kuzzle_1.BadRequestError(`The group affinity models must be an array of models id`);
+            }
+        }
+        return { models, strict, type };
+    }
+    async writeAsset(engineGroups, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, engineIds) {
         if (kuzzle_1.Inflector.pascalCase(model) !== model) {
             throw new kuzzle_1.BadRequestError(`Asset model "${model}" must be PascalCase.`);
         }
@@ -113,6 +163,55 @@ class ModelService extends shared_1.BaseService {
         if (duplicates.length > 0) {
             throw new MeasuresNamesDuplicatesError_1.MeasuresNamesDuplicatesError("Asset model measures contain one or multiple duplicate measure name", duplicates);
         }
+        const normalizedEngineGroups = engineGroups.includes("commons")
+            ? ["commons"]
+            : engineGroups;
+        // Anti-shadowing: reject if a model with the same name exists at a different scope level
+        const isGlobal = normalizedEngineGroups.includes("commons") &&
+            (!engineIds || engineIds.length === 0);
+        const isTenantScoped = engineIds && engineIds.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.engineGroups?.includes("commons") &&
+                (!doc.engineIds || doc.engineIds.length === 0);
+            const docIsTenantScoped = doc.engineIds && doc.engineIds.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.`);
+            }
+        }
         const modelContent = {
             asset: {
                 defaultMetadata,
@@ -124,7 +223,8 @@ class ModelService extends shared_1.BaseService {
                 model,
                 tooltipModels,
             },
-            engineGroup,
+            engineGroups: normalizedEngineGroups,
+            ...(engineIds?.length ? { engineIds } : {}),
             type: "asset",
         };
         this.checkDefaultValues(metadataMappings, defaultMetadata);
@@ -132,40 +232,14 @@ class ModelService extends shared_1.BaseService {
         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.adminIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("asset", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.MODELS);
+        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,
         });
         return assetModel;
     }
-    checkDefaultValues(metadataMappings, defaultMetadata) {
-        const flattenedMetadataMappings = (0, shared_1.flattenObject)(metadataMappings);
-        const metadata = Object.keys(JSON.parse(JSON.stringify(flattenedMetadataMappings)
-            .replace(/properties\./g, "")
-            .replace(/\.type/g, "")));
-        const values = Object.keys((0, shared_1.flattenObject)(defaultMetadata));
-        for (let i = 0; i < values.length; i++) {
-            const key = values[i];
-            // ? Check if the exact key exists in the metadata
-            if (!metadata.includes(key)) {
-                // ? Extract base key for complex types like geo_point or geo_shape
-                const baseKey = key.includes(".") ? key.split(".")[0] : key;
-                // ? Check if the base key is in the metadata
-                if (!metadata.includes(baseKey)) {
-                    throw new kuzzle_1.BadRequestError(`The default value "${key}" is not in the metadata mappings.`);
-                }
-                // ? Accept nested properties for geo_point or geo_shape
-                const baseKeyMetadata = flattenedMetadataMappings[`${baseKey}.type`];
-                if (baseKeyMetadata === "geo_point" ||
-                    baseKeyMetadata === "geo_shape") {
-                    continue;
-                }
-                throw new kuzzle_1.BadRequestError(`The default value "${values[i]}" is not in the metadata mappings.`);
-            }
-        }
-    }
     async writeDevice(model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures) {
         if (kuzzle_1.Inflector.pascalCase(model) !== model) {
             throw new kuzzle_1.BadRequestError(`Device model "${model}" must be PascalCase.`);
@@ -189,18 +263,26 @@ class ModelService extends shared_1.BaseService {
         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.adminIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("device", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.MODELS);
+        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,
+        });
         return deviceModel;
     }
-    async writeGroup(engineGroup, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups) {
+    async writeGroup(engineGroups, model, affinity, metadataMappings, defaultMetadata, metadataDetails, metadataGroups) {
         if (kuzzle_1.Inflector.pascalCase(model) !== model) {
             throw new kuzzle_1.BadRequestError(`Group model "${model}" must be PascalCase.`);
         }
+        if (engineGroups.includes("commons")) {
+            engineGroups = ["commons"];
+        }
+        const groupAffinity = this.checkGroupAffinity(affinity);
         const modelContent = {
-            engineGroup,
+            engineGroups,
             group: {
+                affinity: groupAffinity,
                 defaultMetadata,
                 metadataDetails,
                 metadataGroups,
@@ -213,12 +295,12 @@ class ModelService extends shared_1.BaseService {
         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.adminIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("group", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.MODELS);
+        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;
     }
-    async writeMeasure(type, valuesMappings, validationSchema, valuesDetails, locales) {
+    async writeMeasure(type, valuesMappings, validationSchema, valuesDetails, locales, engineIds) {
         const modelContent = {
             measure: {
                 locales,
@@ -228,6 +310,11 @@ class ModelService extends shared_1.BaseService {
             },
             type: "measure",
         };
+        if (engineIds?.length) {
+            modelContent.engineIds = engineIds;
+        }
+        // Anti-shadowing: a measure type must be either global or tenant-scoped, not both
+        await this.checkMeasureShadowing(type, engineIds);
         if (validationSchema) {
             try {
                 (0, AJValidator_1.addSchemaToCache)(type, validationSchema);
@@ -241,25 +328,25 @@ 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.adminIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("measure", modelContent), modelContent);
-        await this.sdk.collection.refresh(this.config.adminIndex, plugin_1.InternalCollection.MODELS);
+        const measureModel = await this.sdk.document.createOrReplace(this.config.platformIndex, plugin_1.InternalCollection.MODELS, ModelSerializer_1.ModelSerializer.id("measure", 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 measureModel;
     }
     async deleteAsset(_id) {
-        await this.sdk.document.delete(this.config.adminIndex, plugin_1.InternalCollection.MODELS, _id);
+        await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
     }
     async deleteDevice(_id) {
-        await this.sdk.document.delete(this.config.adminIndex, plugin_1.InternalCollection.MODELS, _id);
+        await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
     }
     async deleteGroup(_id) {
-        await this.sdk.document.delete(this.config.adminIndex, plugin_1.InternalCollection.MODELS, _id);
+        await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
     }
     async deleteMeasure(_id) {
-        await this.sdk.document.delete(this.config.adminIndex, plugin_1.InternalCollection.MODELS, _id);
+        await this.sdk.document.delete(this.config.platformIndex, plugin_1.InternalCollection.MODELS, _id);
     }
-    async listAsset(engineGroup) {
-        const result = await this.searchAssets(engineGroup, {
+    async listAsset(engineGroups, engineId) {
+        const result = await this.searchAssets(engineGroups, engineId, {
             searchBody: {
                 sort: { "asset.model": "asc" },
             },
@@ -276,8 +363,8 @@ class ModelService extends shared_1.BaseService {
         });
         return result.hits;
     }
-    async listGroups(engineGroup) {
-        const result = await this.searchGroups(engineGroup, {
+    async listGroups(engineGroups) {
+        const result = await this.searchGroups(engineGroups, {
             searchBody: {
                 sort: { "group.model": "asc" },
             },
@@ -285,8 +372,8 @@ class ModelService extends shared_1.BaseService {
         });
         return result.hits;
     }
-    async listMeasures() {
-        const result = await this.searchMeasures({
+    async listMeasures(engineId) {
+        const result = await this.searchMeasures(engineId, {
             searchBody: {
                 sort: { "measure.type": "asc" },
             },
@@ -294,24 +381,62 @@ class ModelService extends shared_1.BaseService {
         });
         return result.hits;
     }
-    async searchAssets(engineGroup, searchParams) {
+    async searchAssets(engineGroups, engineId, searchParams) {
+        const scopeFilter = engineId
+            ? {
+                bool: {
+                    should: [
+                        {
+                            bool: {
+                                must: [
+                                    { term: { engineIds: engineId } },
+                                    { terms: { engineGroups } },
+                                ],
+                            },
+                        },
+                        {
+                            bool: {
+                                must: [{ terms: { engineGroups } }],
+                                must_not: [{ exists: { field: "engineIds" } }],
+                            },
+                        },
+                        {
+                            bool: {
+                                must: [{ term: { engineGroups: "commons" } }],
+                                must_not: [{ exists: { field: "engineIds" } }],
+                            },
+                        },
+                    ],
+                },
+            }
+            : {
+                bool: {
+                    should: [
+                        {
+                            bool: {
+                                must: [{ terms: { engineGroups } }],
+                                must_not: [{ exists: { field: "engineIds" } }],
+                            },
+                        },
+                        {
+                            bool: {
+                                must: [{ term: { engineGroups: "commons" } }],
+                                must_not: [{ exists: { field: "engineIds" } }],
+                            },
+                        },
+                    ],
+                },
+            };
         const query = {
             bool: {
                 must: [
                     searchParams.searchBody.query,
-                    { match: { type: "asset" } },
-                    {
-                        bool: {
-                            should: [
-                                { match: { engineGroup } },
-                                { match: { engineGroup: "commons" } },
-                            ],
-                        },
-                    },
-                ],
+                    { term: { type: "asset" } },
+                    scopeFilter,
+                ].filter(Boolean),
             },
         };
-        return this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, {
+        return this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
             ...searchParams.searchBody,
             query,
         }, {
@@ -324,10 +449,13 @@ class ModelService extends shared_1.BaseService {
     async searchDevices(searchParams) {
         const query = {
             bool: {
-                must: [searchParams.searchBody.query, { match: { type: "device" } }],
+                must: [
+                    searchParams.searchBody.query,
+                    { term: { type: "device" } },
+                ].filter(Boolean),
             },
         };
-        return this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, {
+        return this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
             ...searchParams.searchBody,
             query,
         }, {
@@ -337,24 +465,24 @@ class ModelService extends shared_1.BaseService {
             size: searchParams.size,
         });
     }
-    async searchGroups(engineGroup, searchParams) {
+    async searchGroups(engineGroups, searchParams) {
         const query = {
             bool: {
                 must: [
                     searchParams.searchBody.query,
-                    { match: { type: "group" } },
+                    { term: { type: "group" } },
                     {
                         bool: {
                             should: [
-                                { match: { engineGroup } },
-                                { match: { engineGroup: "commons" } },
+                                { terms: { engineGroups } },
+                                { term: { engineGroups: "commons" } },
                             ],
                         },
                     },
-                ],
+                ].filter(Boolean),
             },
         };
-        return this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, {
+        return this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
             ...searchParams.searchBody,
             query,
         }, {
@@ -364,13 +492,31 @@ class ModelService extends shared_1.BaseService {
             size: searchParams.size,
         });
     }
-    async searchMeasures(searchParams) {
+    async searchMeasures(engineId, searchParams) {
+        const scopeFilter = engineId
+            ? {
+                bool: {
+                    should: [
+                        { term: { engineIds: engineId } },
+                        { bool: { must_not: [{ exists: { field: "engineIds" } }] } },
+                    ],
+                },
+            }
+            : {
+                bool: {
+                    must_not: [{ exists: { field: "engineIds" } }],
+                },
+            };
         const query = {
             bool: {
-                must: [searchParams.searchBody.query, { match: { type: "measure" } }],
+                must: [
+                    searchParams.searchBody.query,
+                    { term: { type: "measure" } },
+                    scopeFilter,
+                ].filter(Boolean),
             },
         };
-        return this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, {
+        return this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
             ...searchParams.searchBody,
             query,
         }, {
@@ -387,7 +533,7 @@ class ModelService extends shared_1.BaseService {
                 { equals: { "asset.model": model } },
             ],
         };
-        const result = await this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
         return result.total > 0;
     }
     async deviceExists(model) {
@@ -397,27 +543,53 @@ class ModelService extends shared_1.BaseService {
                 { equals: { "device.model": model } },
             ],
         };
-        const result = await this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
         return result.total > 0;
     }
-    async getAsset(engineGroup, model) {
-        const query = {
-            and: [
-                {
-                    or: [
-                        { equals: { engineGroup } },
-                        { equals: { engineGroup: "commons" } },
+    async getAsset(engineGroups, engineId, model) {
+        const baseFilter = [
+            { term: { type: "asset" } },
+            { term: { "asset.model": model } },
+        ];
+        // Priority 1: tenant-scoped model for this specific engine
+        if (engineId) {
+            const tenantQuery = {
+                bool: {
+                    must: [
+                        ...baseFilter,
+                        { terms: { engineGroups } },
+                        { term: { engineIds: engineId } },
                     ],
                 },
-                { equals: { type: "asset" } },
-                { equals: { "asset.model": model } },
-            ],
+            };
+            const tenantResult = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: tenantQuery }, { lang: "elasticsearch", size: 1 });
+            if (tenantResult.total > 0) {
+                return tenantResult.hits[0];
+            }
+        }
+        // Priority 2: group-scoped model (no engineIds field)
+        const groupQuery = {
+            bool: {
+                must: [...baseFilter, { terms: { engineGroups } }],
+                must_not: [{ exists: { field: "engineIds" } }],
+            },
         };
-        const result = await this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
-        if (result.total === 0) {
-            throw new kuzzle_1.NotFoundError(`Unknown Asset model "${model}" for engineGroup ${engineGroup}.`);
+        const groupResult = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: groupQuery }, { lang: "elasticsearch", size: 1 });
+        if (groupResult.total > 0) {
+            return groupResult.hits[0];
         }
-        return result.hits[0];
+        // Priority 3: commons model
+        const commonsQuery = {
+            bool: {
+                must: [...baseFilter, { term: { engineGroups: "commons" } }],
+                must_not: [{ exists: { field: "engineIds" } }],
+            },
+        };
+        const commonsResult = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: commonsQuery }, { lang: "elasticsearch", size: 1 });
+        if (commonsResult.total > 0) {
+            return commonsResult.hits[0];
+        }
+        throw new kuzzle_1.NotFoundError(`Unknown Asset model "${model}" for engineGroups ${engineGroups.join(", ")}.`);
     }
     async getDevice(model) {
         const query = {
@@ -426,7 +598,7 @@ class ModelService extends shared_1.BaseService {
                 { equals: { "device.model": model } },
             ],
         };
-        const result = await this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
         if (result.total === 0) {
             throw new kuzzle_1.NotFoundError(`Unknown Device model "${model}".`);
         }
@@ -439,7 +611,7 @@ class ModelService extends shared_1.BaseService {
                 { equals: { "group.model": model } },
             ],
         };
-        const result = await this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
         if (result.total === 0) {
             throw new kuzzle_1.NotFoundError(`Unknown Group model "${model}".`);
         }
@@ -448,31 +620,92 @@ class ModelService extends shared_1.BaseService {
         }
         return result.hits[0];
     }
-    async getMeasure(type) {
-        const query = {
-            and: [
-                { equals: { type: "measure" } },
-                { equals: { "measure.type": type } },
-            ],
-        };
-        const result = await this.sdk.document.search(this.config.adminIndex, plugin_1.InternalCollection.MODELS, { query }, { lang: "koncorde", size: 1 });
-        if (result.total === 0) {
-            throw new kuzzle_1.NotFoundError(`Unknown Measure type "${type}".`);
+    async getMeasure(type, engineId) {
+        const baseFilter = [
+            { term: { type: "measure" } },
+            { term: { "measure.type": type } },
+        ];
+        const scopeFilter = engineId
+            ? {
+                bool: {
+                    should: [
+                        { term: { engineIds: engineId } },
+                        { bool: { must_not: [{ exists: { field: "engineIds" } }] } },
+                    ],
+                },
+            }
+            : {
+                bool: {
+                    must_not: [{ exists: { field: "engineIds" } }],
+                },
+            };
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, {
+            query: {
+                bool: {
+                    must: [...baseFilter, scopeFilter],
+                },
+            },
+        }, { lang: "elasticsearch", size: 1 });
+        if (result.total > 0) {
+            return result.hits[0];
+        }
+        throw new kuzzle_1.NotFoundError(`Unknown Measure type "${type}".`);
+    }
+    /**
+     * Checks that creating/updating a measure model does not shadow an existing
+     * one at a different scope (global vs tenant-scoped).
+     */
+    async checkMeasureShadowing(type, engineIds) {
+        const isNewTenantScoped = engineIds && engineIds.length > 0;
+        // Check for existing measures of the same type at the opposite scope
+        const conflictQuery = isNewTenantScoped
+            ? {
+                // New is tenant-scoped → reject if a global measure exists
+                bool: {
+                    must: [
+                        { term: { type: "measure" } },
+                        { term: { "measure.type": type } },
+                    ],
+                    must_not: [{ exists: { field: "engineIds" } }],
+                },
+            }
+            : {
+                // New is global → reject if any tenant-scoped measure exists
+                bool: {
+                    must: [
+                        { term: { type: "measure" } },
+                        { term: { "measure.type": type } },
+                        { exists: { field: "engineIds" } },
+                    ],
+                },
+            };
+        const result = await this.sdk.document.search(this.config.platformIndex, plugin_1.InternalCollection.MODELS, { query: conflictQuery }, { lang: "elasticsearch", size: 1 });
+        if (result.total > 0) {
+            const scope = isNewTenantScoped ? "global" : "tenant-scoped";
+            throw new kuzzle_1.BadRequestError(`Measure type "${type}" already exists as a ${scope} measure. A measure type cannot be both global and tenant-scoped.`);
         }
-        return result.hits[0];
     }
     /**
      * Update an asset model
      */
-    async updateAsset(engineGroup, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, request) {
+    async updateAsset(engineGroups, engineId, model, metadataMappings, defaultMetadata, metadataDetails, metadataGroups, measures, tooltipModels, locales, 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(engineGroup, model);
+        const existingAsset = await this.getAsset(engineGroups, engineId, model);
         // The field must be deleted if an element of the table is to be deleted
-        await this.sdk.document.deleteFields(this.config.adminIndex, plugin_1.InternalCollection.MODELS, existingAsset._id, ["asset.tooltipModels"], { source: true });
+        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;
+        const normalizedEngineGroups = engineGroups.includes("commons")
+            ? ["commons"]
+            : engineGroups;
         const assetModelContent = {
             asset: {
                 defaultMetadata,
@@ -484,7 +717,8 @@ class ModelService extends shared_1.BaseService {
                 model,
                 tooltipModels,
             },
-            engineGroup,
+            engineGroups: normalizedEngineGroups,
+            engineIds: existingAsset._source.engineIds,
             type: "asset",
         };
         const assetModel = {
@@ -497,13 +731,16 @@ class ModelService extends shared_1.BaseService {
         }
         const endDocument = await this.updateDocument(request, assetModel, {
             collection: plugin_1.InternalCollection.MODELS,
-            engineId: this.config.adminIndex,
+            engineId: this.config.platformIndex,
         }, { source: true });
-        await this.sdk.collection.refresh(this.config.adminIndex, 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,
-        });
+        // ? Only update engineIds and refresh asset models when necessary
+        if (Object.keys(metadataMappings).length > 0 || measures.length > 0) {
+            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,
+            });
+        }
         return endDocument;
     }
 }